From 116f67036f503405b80a4d8baa429a6166490b80 Mon Sep 17 00:00:00 2001
From: Thomas Waldmann <tw@waldmann-edv.de>
Date: Tue, 3 May 2022 03:01:03 +0200
Subject: [PATCH 001/160] transfer: copy archives from another repo

this is somehow similar to borg recreate,
but with different focus and way simpler:

not changing compression algo
not changing chunking
not excluding files inside an archive by path match
only dealing with complete archives

but:
different src and dst repo
only reading each chunk once
keeping the compressed payload (no decompression/recompression effort)
--dry-run can be used before and afterwards to check
---
 src/borg/archiver.py | 105 +++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 105 insertions(+)

diff --git a/src/borg/archiver.py b/src/borg/archiver.py
index de9489ff0..49516fff6 100644
--- a/src/borg/archiver.py
+++ b/src/borg/archiver.py
@@ -338,6 +338,74 @@ class Archiver:
         ).serve()
         return EXIT_SUCCESS
 
+    @with_other_repository(manifest=True, key=True, compatibility=(Manifest.Operation.READ,))
+    @with_repository(exclusive=True, manifest=True, cache=True, compatibility=(Manifest.Operation.WRITE,))
+    def do_transfer(self, args, *,
+               repository, manifest, key, cache,
+               other_repository=None, other_manifest=None, other_key=None):
+        """archives transfer from other repository"""
+        dry_run = args.dry_run
+
+        args.consider_checkpoints = True
+        archive_names = tuple(x.name for x in other_manifest.archives.list_considering(args))
+        if not archive_names:
+            return EXIT_SUCCESS
+
+        for name in archive_names:
+            transfer_size = 0
+            present_size = 0
+            if name in manifest.archives and not dry_run:
+                print(f"{name}: archive is already present in destination repo, skipping.")
+            else:
+                if not dry_run:
+                    print(f"{name}: copying archive to destination repo...")
+                other_archive = Archive(other_repository, other_key, other_manifest, name)
+                archive = Archive(repository, key, manifest, name, cache=cache, create=True) if not dry_run else None
+                for item in other_archive.iter_items():
+                    if 'chunks' in item:
+                        chunks = []
+                        for chunk_id, size, _ in item.chunks:
+                            refcount = cache.seen_chunk(chunk_id, size)
+                            if refcount == 0:  # target repo does not yet have this chunk
+                                if not dry_run:
+                                    cdata = other_repository.get(chunk_id)
+                                    # keep compressed payload same, avoid decompression / recompression
+                                    data = other_key.decrypt(chunk_id, cdata, decompress=False)
+                                    chunk_entry = cache.add_chunk(chunk_id, data, archive.stats, wait=False,
+                                                                  compress=False, size=size)
+                                    cache.repository.async_response(wait=False)
+                                    chunks.append(chunk_entry)
+                                transfer_size += size
+                            else:
+                                if not dry_run:
+                                    chunk_entry = cache.chunk_incref(chunk_id, archive.stats)
+                                    chunks.append(chunk_entry)
+                                present_size += size
+                        if not dry_run:
+                            item.chunks = chunks  # overwrite! IDs and sizes are same, csizes are likely different
+                            archive.stats.nfiles += 1
+                    # TODO: filter the item data, get rid of legacy crap
+                    if not dry_run:
+                        archive.add_item(item)
+                if not dry_run:
+                    additional_metadata = {}
+                    # keep all metadata except archive version and stats. also do not keep
+                    # recreate_source_id, recreate_args, recreate_partial_chunks which were used only in 1.1.0b1 .. b2.
+                    for attr in ('cmdline', 'hostname', 'username', 'time', 'time_end', 'comment',
+                                 'chunker_params', 'recreate_cmdline'):
+                        if hasattr(other_archive.metadata, attr):
+                            additional_metadata[attr] = getattr(other_archive.metadata, attr)
+                    archive.save(stats=archive.stats, additional_metadata=additional_metadata)
+                    print(f"{name}: finished. "
+                          f"transfer_size: {format_file_size(transfer_size)} "
+                          f"present_size: {format_file_size(present_size)}")
+                else:
+                    print(f"{name}: completed" if transfer_size == 0 else
+                          f"{name}: incomplete, "
+                          f"transfer_size: {format_file_size(transfer_size)} "
+                          f"present_size: {format_file_size(present_size)}")
+        return EXIT_SUCCESS
+
     @with_repository(create=True, exclusive=True, manifest=False)
     @with_other_repository(key=True, compatibility=(Manifest.Operation.READ, ))
     def do_init(self, args, repository, *, other_repository=None, other_key=None):
@@ -4083,6 +4151,43 @@ class Archiver:
                                help='archives to delete')
         define_archive_filters_group(subparser)
 
+        # borg transfer
+        transfer_epilog = process_epilog("""
+        This command transfers archives from one repository to another repository.
+
+        Suggested use:
+
+        # initialize DST_REPO reusing key material from SRC_REPO, so that
+        # chunking and chunk id generation will work in the same way as before.
+        borg init --other-location=SRC_REPO --encryption=DST_ENC DST_REPO
+
+        # transfer archives from SRC_REPO to DST_REPO
+        borg transfer --dry-run SRC_REPO DST_REPO  # check what it would do
+        borg transfer           SRC_REPO DST_REPO  # do it!
+        borg transfer --dry-run SRC_REPO DST_REPO  # check! anything left?
+
+        The default is to transfer all archives, including checkpoint archives.
+
+        You could use the misc. archive filter options to limit which archives it will
+        transfer, e.g. using the --prefix option. This is recommended for big
+        repositories with multiple data sets to keep the runtime per invocation lower.
+        """)
+        subparser = subparsers.add_parser('transfer', parents=[common_parser], add_help=False,
+                                          description=self.do_transfer.__doc__,
+                                          epilog=transfer_epilog,
+                                          formatter_class=argparse.RawDescriptionHelpFormatter,
+                                          help='transfer of archives from another repository')
+        subparser.set_defaults(func=self.do_transfer)
+        subparser.add_argument('-n', '--dry-run', dest='dry_run', action='store_true',
+                               help='do not change repository, just check')
+        subparser.add_argument('other_location', metavar='SRC_REPOSITORY',
+                               type=location_validator(archive=False, other=True),
+                               help='source repository')
+        subparser.add_argument('location', metavar='DST_REPOSITORY',
+                               type=location_validator(archive=False, other=False),
+                               help='destination repository')
+        define_archive_filters_group(subparser)
+
         # borg diff
         diff_epilog = process_epilog("""
             This command finds differences (file contents, user/group/mode) between archives.

From 98b7dc0bf5baecc8a371f78b8ea42fc5f1769c2c Mon Sep 17 00:00:00 2001
From: Thomas Waldmann <tw@waldmann-edv.de>
Date: Tue, 3 May 2022 16:58:57 +0200
Subject: [PATCH 002/160] transfer: clean item of attic 0.13 'acl' bug remnants

also: remove attic bug support code from borg check.

borg transfer removes the acl key. we do not run borg check on old repos.
---
 src/borg/archive.py            |  3 ---
 src/borg/archiver.py           |  9 +++++++--
 src/borg/testsuite/archiver.py | 29 -----------------------------
 3 files changed, 7 insertions(+), 34 deletions(-)

diff --git a/src/borg/archive.py b/src/borg/archive.py
index a9c145d49..ba95a0867 100644
--- a/src/borg/archive.py
+++ b/src/borg/archive.py
@@ -1944,9 +1944,6 @@ class ArchiveChecker:
             def valid_item(obj):
                 if not isinstance(obj, StableDict):
                     return False, 'not a dictionary'
-                # A bug in Attic up to and including release 0.13 added a (meaningless) b'acl' key to every item.
-                # We ignore it here, should it exist. See test_attic013_acl_bug for details.
-                obj.pop(b'acl', None)
                 keys = set(obj)
                 if not required_item_keys.issubset(keys):
                     return False, 'missing required keys: ' + list_keys_safe(required_item_keys - keys)
diff --git a/src/borg/archiver.py b/src/borg/archiver.py
index 49516fff6..a4cddd7b0 100644
--- a/src/borg/archiver.py
+++ b/src/borg/archiver.py
@@ -344,6 +344,12 @@ class Archiver:
                repository, manifest, key, cache,
                other_repository=None, other_manifest=None, other_key=None):
         """archives transfer from other repository"""
+
+        def upgrade_item(item):
+            """upgrade item as needed, get rid of legacy crap"""
+            item._dict.pop('acl', None)  # remove remnants of bug in attic <= 0.13
+            return item
+
         dry_run = args.dry_run
 
         args.consider_checkpoints = True
@@ -384,9 +390,8 @@ class Archiver:
                         if not dry_run:
                             item.chunks = chunks  # overwrite! IDs and sizes are same, csizes are likely different
                             archive.stats.nfiles += 1
-                    # TODO: filter the item data, get rid of legacy crap
                     if not dry_run:
-                        archive.add_item(item)
+                        archive.add_item(upgrade_item(item))
                 if not dry_run:
                     additional_metadata = {}
                     # keep all metadata except archive version and stats. also do not keep
diff --git a/src/borg/testsuite/archiver.py b/src/borg/testsuite/archiver.py
index 450ba1757..5889b12ab 100644
--- a/src/borg/testsuite/archiver.py
+++ b/src/borg/testsuite/archiver.py
@@ -3907,35 +3907,6 @@ class ArchiverCheckTestCase(ArchiverTestCaseBase):
             repository.commit(compact=False)
         self.cmd('check', self.repository_location, exit_code=1)
 
-    def test_attic013_acl_bug(self):
-        # Attic up to release 0.13 contained a bug where every item unintentionally received
-        # a b'acl'=None key-value pair.
-        # This bug can still live on in Borg repositories (through borg upgrade).
-        class Attic013Item:
-            def as_dict(self):
-                return {
-                    # These are required
-                    b'path': '1234',
-                    b'mtime': 0,
-                    b'mode': 0,
-                    b'user': b'0',
-                    b'group': b'0',
-                    b'uid': 0,
-                    b'gid': 0,
-                    # acl is the offending key.
-                    b'acl': None,
-                }
-
-        archive, repository = self.open_archive('archive1')
-        with repository:
-            manifest, key = Manifest.load(repository, Manifest.NO_OPERATION_CHECK)
-            with Cache(repository, key, manifest) as cache:
-                archive = Archive(repository, key, manifest, '0.13', cache=cache, create=True)
-                archive.items_buffer.add(Attic013Item())
-                archive.save()
-        self.cmd('check', self.repository_location, exit_code=0)
-        self.cmd('list', self.repository_location + '::0.13', exit_code=0)
-
 
 class ManifestAuthenticationTest(ArchiverTestCaseBase):
     def spoof_manifest(self, repository):

From ba1dbe6111d5b1f11b2a3d3c43a0fed83b2e7392 Mon Sep 17 00:00:00 2001
From: Thomas Waldmann <tw@waldmann-edv.de>
Date: Tue, 3 May 2022 17:13:37 +0200
Subject: [PATCH 003/160] transfer: make sure items with chunks have
 precomputed size

---
 src/borg/archiver.py | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/borg/archiver.py b/src/borg/archiver.py
index a4cddd7b0..0c5dee5f1 100644
--- a/src/borg/archiver.py
+++ b/src/borg/archiver.py
@@ -348,6 +348,7 @@ class Archiver:
         def upgrade_item(item):
             """upgrade item as needed, get rid of legacy crap"""
             item._dict.pop('acl', None)  # remove remnants of bug in attic <= 0.13
+            item.get_size(memorize=True)  # if not already present: compute+remember size for items with chunks
             return item
 
         dry_run = args.dry_run

From 01f72d15b4c4ebd5dd21e6787dacf0b44d433d5c Mon Sep 17 00:00:00 2001
From: Thomas Waldmann <tw@waldmann-edv.de>
Date: Tue, 3 May 2022 20:51:43 +0200
Subject: [PATCH 004/160] transfer: remove the zlib type bytes hack

hack: see the docstring of ZLIB_legacy class.

New clean ZLIB class that works as every other compressor.

ZLIB ID 0x0500, ZLIB_legacy ID 0x.8..
---
 src/borg/archiver.py           |  8 +++++-
 src/borg/compress.pyx          | 51 ++++++++++++++++++++++++++++++----
 src/borg/testsuite/archiver.py |  4 +--
 src/borg/testsuite/compress.py |  4 +--
 4 files changed, 56 insertions(+), 11 deletions(-)

diff --git a/src/borg/archiver.py b/src/borg/archiver.py
index 0c5dee5f1..098208167 100644
--- a/src/borg/archiver.py
+++ b/src/borg/archiver.py
@@ -44,7 +44,7 @@ try:
     from .archive import has_link
     from .cache import Cache, assert_secure, SecurityManager
     from .constants import *  # NOQA
-    from .compress import CompressionSpec
+    from .compress import CompressionSpec, ZLIB, ZLIB_legacy
     from .crypto.key import key_creator, key_argument_names, tam_required_file, tam_required
     from .crypto.key import RepoKey, KeyfileKey, Blake2RepoKey, Blake2KeyfileKey, FlexiKey
     from .crypto.keymanager import KeyManager
@@ -351,6 +351,11 @@ class Archiver:
             item.get_size(memorize=True)  # if not already present: compute+remember size for items with chunks
             return item
 
+        def upgrade_compressed_chunk(chunk):
+            if ZLIB_legacy.detect(chunk):
+                chunk = ZLIB.ID + chunk  # get rid of the attic legacy: prepend separate type bytes for zlib
+            return chunk
+
         dry_run = args.dry_run
 
         args.consider_checkpoints = True
@@ -378,6 +383,7 @@ class Archiver:
                                     cdata = other_repository.get(chunk_id)
                                     # keep compressed payload same, avoid decompression / recompression
                                     data = other_key.decrypt(chunk_id, cdata, decompress=False)
+                                    data = upgrade_compressed_chunk(data)
                                     chunk_entry = cache.add_chunk(chunk_id, data, archive.stats, wait=False,
                                                                   compress=False, size=size)
                                     cache.repository.async_response(wait=False)
diff --git a/src/borg/compress.pyx b/src/borg/compress.pyx
index 2e0eb4809..7997456c6 100644
--- a/src/borg/compress.pyx
+++ b/src/borg/compress.pyx
@@ -331,14 +331,52 @@ class ZSTD(DecidingCompressor):
         return dest[:osize]
 
 
-class ZLIB(CompressorBase):
+class ZLIB(DecidingCompressor):
     """
     zlib compression / decompression (python stdlib)
     """
-    ID = b'\x08\x00'  # not used here, see detect()
-                      # avoid all 0x.8.. IDs elsewhere!
+    ID = b'\x05\x00'
     name = 'zlib'
 
+    def __init__(self, level=6, **kwargs):
+        super().__init__(**kwargs)
+        self.level = level
+
+    def _decide(self, data):
+        """
+        Decides what to do with *data*. Returns (compressor, zlib_data).
+
+        *zlib_data* is the ZLIB result if *compressor* is ZLIB as well, otherwise it is None.
+        """
+        zlib_data = zlib.compress(data, self.level)
+        if len(zlib_data) < len(data):
+            return self, zlib_data
+        else:
+            return NONE_COMPRESSOR, None
+
+    def decompress(self, data):
+        data = super().decompress(data)
+        try:
+            return zlib.decompress(data)
+        except zlib.error as e:
+            raise DecompressionError(str(e)) from None
+
+
+class ZLIB_legacy(CompressorBase):
+    """
+    zlib compression / decompression (python stdlib)
+
+    Note: This is the legacy ZLIB support as used by borg < 1.3.
+          It still suffers from attic *only* supporting zlib and not having separate
+          ID bytes to differentiate between differently compressed chunks.
+          This just works because zlib compressed stuff always starts with 0x.8.. bytes.
+          Newer borg uses the ZLIB class that has separate ID bytes (as all the other
+          compressors) and does not need this hack.
+    """
+    ID = b'\x08\x00'  # not used here, see detect()
+    # avoid all 0x.8.. IDs elsewhere!
+    name = 'zlib_legacy'
+
     @classmethod
     def detect(cls, data):
         # matches misc. patterns 0x.8.. used by zlib
@@ -502,13 +540,14 @@ COMPRESSOR_TABLE = {
     CNONE.name: CNONE,
     LZ4.name: LZ4,
     ZLIB.name: ZLIB,
+    ZLIB_legacy.name: ZLIB_legacy,
     LZMA.name: LZMA,
     Auto.name: Auto,
     ZSTD.name: ZSTD,
     ObfuscateSize.name: ObfuscateSize,
 }
 # List of possible compression types. Does not include Auto, since it is a meta-Compressor.
-COMPRESSOR_LIST = [LZ4, ZSTD, CNONE, ZLIB, LZMA, ObfuscateSize, ]  # check fast stuff first
+COMPRESSOR_LIST = [LZ4, ZSTD, CNONE, ZLIB, ZLIB_legacy, LZMA, ObfuscateSize, ]  # check fast stuff first
 
 def get_compressor(name, **kwargs):
     cls = COMPRESSOR_TABLE[name]
@@ -554,7 +593,7 @@ class CompressionSpec:
         self.name = values[0]
         if self.name in ('none', 'lz4', ):
             return
-        elif self.name in ('zlib', 'lzma', ):
+        elif self.name in ('zlib', 'lzma', 'zlib_legacy'):  # zlib_legacy just for testing
             if count < 2:
                 level = 6  # default compression level in py stdlib
             elif count == 2:
@@ -597,7 +636,7 @@ class CompressionSpec:
     def compressor(self):
         if self.name in ('none', 'lz4', ):
             return get_compressor(self.name)
-        elif self.name in ('zlib', 'lzma', 'zstd', ):
+        elif self.name in ('zlib', 'lzma', 'zstd', 'zlib_legacy'):
             return get_compressor(self.name, level=self.level)
         elif self.name == 'auto':
             return get_compressor(self.name, compressor=self.inner.compressor)
diff --git a/src/borg/testsuite/archiver.py b/src/borg/testsuite/archiver.py
index 5889b12ab..b69fe819f 100644
--- a/src/borg/testsuite/archiver.py
+++ b/src/borg/testsuite/archiver.py
@@ -2442,7 +2442,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
     def test_compression_zlib_compressible(self):
         size, csize = self._get_sizes('zlib', compressible=True)
         assert csize < size * 0.1
-        assert csize == 35
+        assert csize == 37
 
     def test_compression_zlib_uncompressible(self):
         size, csize = self._get_sizes('zlib', compressible=False)
@@ -2451,7 +2451,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
     def test_compression_auto_compressible(self):
         size, csize = self._get_sizes('auto,zlib', compressible=True)
         assert csize < size * 0.1
-        assert csize == 35  # same as compression 'zlib'
+        assert csize == 37  # same as compression 'zlib'
 
     def test_compression_auto_uncompressible(self):
         size, csize = self._get_sizes('auto,zlib', compressible=False)
diff --git a/src/borg/testsuite/compress.py b/src/borg/testsuite/compress.py
index 3942c3537..c93dd3bb6 100644
--- a/src/borg/testsuite/compress.py
+++ b/src/borg/testsuite/compress.py
@@ -88,11 +88,11 @@ def test_autodetect_invalid():
         Compressor(**params).decompress(b'\x08\x00notreallyzlib')
 
 
-def test_zlib_compat():
+def test_zlib_legacy_compat():
     # for compatibility reasons, we do not add an extra header for zlib,
     # nor do we expect one when decompressing / autodetecting
     for level in range(10):
-        c = get_compressor(name='zlib', level=level)
+        c = get_compressor(name='zlib_legacy', level=level)
         cdata1 = c.compress(data)
         cdata2 = zlib.compress(data, level)
         assert cdata1 == cdata2

From e4a97ea8cc475b5eb5f5f43d622a485874224727 Mon Sep 17 00:00:00 2001
From: Thomas Waldmann <tw@waldmann-edv.de>
Date: Wed, 4 May 2022 01:58:24 +0200
Subject: [PATCH 005/160] transfer: all hardlinks have chunks, maybe
 chunks_healty, hlid

Item.hlid: same id, same hardlink (xxh64 digest)
Item.hardlink_master: not used for new archives any more
Item.source: not used for hardlink slaves any more
---
 src/borg/archiver.py  | 15 +++++++++++++++
 src/borg/constants.py |  2 +-
 src/borg/item.pyx     |  3 ++-
 3 files changed, 18 insertions(+), 2 deletions(-)

diff --git a/src/borg/archiver.py b/src/borg/archiver.py
index 098208167..ea70f412a 100644
--- a/src/borg/archiver.py
+++ b/src/borg/archiver.py
@@ -347,6 +347,20 @@ class Archiver:
 
         def upgrade_item(item):
             """upgrade item as needed, get rid of legacy crap"""
+            if item.get('hardlink_master', True) and 'source' not in item and hardlinkable(item.mode):
+                item._dict['hlid'] = hlid = hashlib.sha256(item._dict['path'])
+                hardlink_masters[hlid] = (item._dict.get('chunks'), item._dict.get('chunks_healthy'))
+            elif 'source' in item and hardlinkable(item.mode):
+                item._dict['hlid'] = hlid = hashlib.sha256(item._dict['source'])
+                chunks, chunks_healthy = hardlink_masters.get(hlid, (None, None))
+                if chunks is not None:
+                    item._dict['chunks'] = chunks
+                    for chunk_id, _, _ in chunks:
+                        cache.chunk_incref(chunk_id, archive.stats)
+                if chunks_healthy is not None:
+                    item._dict['chunks_healthy'] = chunks
+                item._dict.pop('source')  # not used for hardlinks any more, replaced by hlid
+            item._dict.pop('hardlink_master', None)  # not used for hardlinks any more, replaced by hlid
             item._dict.pop('acl', None)  # remove remnants of bug in attic <= 0.13
             item.get_size(memorize=True)  # if not already present: compute+remember size for items with chunks
             return item
@@ -371,6 +385,7 @@ class Archiver:
             else:
                 if not dry_run:
                     print(f"{name}: copying archive to destination repo...")
+                hardlink_masters = {}
                 other_archive = Archive(other_repository, other_key, other_manifest, name)
                 archive = Archive(repository, key, manifest, name, cache=cache, create=True) if not dry_run else None
                 for item in other_archive.iter_items():
diff --git a/src/borg/constants.py b/src/borg/constants.py
index 0b2ef16a1..13eb8bd23 100644
--- a/src/borg/constants.py
+++ b/src/borg/constants.py
@@ -1,5 +1,5 @@
 # this set must be kept complete, otherwise the RobustUnpacker might malfunction:
-ITEM_KEYS = frozenset(['path', 'source', 'rdev', 'chunks', 'chunks_healthy', 'hardlink_master',
+ITEM_KEYS = frozenset(['path', 'source', 'rdev', 'chunks', 'chunks_healthy', 'hardlink_master', 'hlid',
                        'mode', 'user', 'group', 'uid', 'gid', 'mtime', 'atime', 'ctime', 'birthtime', 'size',
                        'xattrs', 'bsdflags', 'acl_nfs4', 'acl_access', 'acl_default', 'acl_extended',
                        'part'])
diff --git a/src/borg/item.pyx b/src/borg/item.pyx
index 48debf183..0b2598ffe 100644
--- a/src/borg/item.pyx
+++ b/src/borg/item.pyx
@@ -181,7 +181,8 @@ class Item(PropDict):
     # compatibility note: this is a new feature, in old archives size will be missing.
     size = PropDict._make_property('size', int)
 
-    hardlink_master = PropDict._make_property('hardlink_master', bool)
+    hlid = PropDict._make_property('hlid', bytes)  # hard link id: same value means same hard link.
+    hardlink_master = PropDict._make_property('hardlink_master', bool)  # legacy
 
     chunks = PropDict._make_property('chunks', (list, type(None)), 'list or None')
     chunks_healthy = PropDict._make_property('chunks_healthy', (list, type(None)), 'list or None')

From 7903dad1839c0c1e3a64dbbce8115e2d8aae5804 Mon Sep 17 00:00:00 2001
From: Thomas Waldmann <tw@waldmann-edv.de>
Date: Wed, 4 May 2022 10:34:33 +0200
Subject: [PATCH 006/160] transfer: convert timestamps int/bigint ->
 msgpack.Timestamp, see #2323

Timestamp scales to 64 or 96bit serialization formats, that should be enough for everybody.

We use this in archived items and also in the files cache.
---
 src/borg/archiver.py            |  4 ++++
 src/borg/cache.py               | 11 ++++++-----
 src/borg/helpers/msgpack.py     | 17 ++++++++++++++---
 src/borg/helpers/parseformat.py |  3 +++
 src/borg/item.pyx               | 11 +++++------
 src/borg/testsuite/item.py      |  7 ++++---
 6 files changed, 36 insertions(+), 17 deletions(-)

diff --git a/src/borg/archiver.py b/src/borg/archiver.py
index ea70f412a..eac059bb7 100644
--- a/src/borg/archiver.py
+++ b/src/borg/archiver.py
@@ -360,6 +360,10 @@ class Archiver:
                 if chunks_healthy is not None:
                     item._dict['chunks_healthy'] = chunks
                 item._dict.pop('source')  # not used for hardlinks any more, replaced by hlid
+            for attr in 'atime', 'ctime', 'mtime', 'birthtime':
+                if attr in item:
+                    ns = getattr(item, attr)  # decode (bigint or Timestamp) --> int ns
+                    setattr(item, attr, ns)  # encode int ns --> msgpack.Timestamp only, no bigint any more
             item._dict.pop('hardlink_master', None)  # not used for hardlinks any more, replaced by hlid
             item._dict.pop('acl', None)  # remove remnants of bug in attic <= 0.13
             item.get_size(memorize=True)  # if not already present: compute+remember size for items with chunks
diff --git a/src/borg/cache.py b/src/borg/cache.py
index 6fa74e692..6cd612359 100644
--- a/src/borg/cache.py
+++ b/src/borg/cache.py
@@ -19,7 +19,7 @@ from .helpers import Location
 from .helpers import Error
 from .helpers import Manifest
 from .helpers import get_cache_dir, get_security_dir
-from .helpers import int_to_bigint, bigint_to_int, bin_to_hex, parse_stringified_list
+from .helpers import bin_to_hex, parse_stringified_list
 from .helpers import format_file_size
 from .helpers import safe_ns
 from .helpers import yes
@@ -28,6 +28,7 @@ from .helpers import ProgressIndicatorPercent, ProgressIndicatorMessage
 from .helpers import set_ec, EXIT_WARNING
 from .helpers import safe_unlink
 from .helpers import msgpack
+from .helpers.msgpack import int_to_timestamp, timestamp_to_int
 from .item import ArchiveItem, ChunkListEntry
 from .crypto.key import PlaintextKey
 from .crypto.file_integrity import IntegrityCheckedFile, DetachedIntegrityCheckedFile, FileIntegrityError
@@ -623,7 +624,7 @@ class LocalCache(CacheStatsMixin):
                     # this is to avoid issues with filesystem snapshots and cmtime granularity.
                     # Also keep files from older backups that have not reached BORG_FILES_CACHE_TTL yet.
                     entry = FileCacheEntry(*msgpack.unpackb(item))
-                    if entry.age == 0 and bigint_to_int(entry.cmtime) < self._newest_cmtime or \
+                    if entry.age == 0 and timestamp_to_int(entry.cmtime) < self._newest_cmtime or \
                        entry.age > 0 and entry.age < ttl:
                         msgpack.pack((path_hash, entry), fd)
                         entry_count += 1
@@ -1018,10 +1019,10 @@ class LocalCache(CacheStatsMixin):
         if 'i' in cache_mode and entry.inode != st.st_ino:
             files_cache_logger.debug('KNOWN-CHANGED: file inode number has changed: %r', hashed_path)
             return True, None
-        if 'c' in cache_mode and bigint_to_int(entry.cmtime) != st.st_ctime_ns:
+        if 'c' in cache_mode and timestamp_to_int(entry.cmtime) != st.st_ctime_ns:
             files_cache_logger.debug('KNOWN-CHANGED: file ctime has changed: %r', hashed_path)
             return True, None
-        elif 'm' in cache_mode and bigint_to_int(entry.cmtime) != st.st_mtime_ns:
+        elif 'm' in cache_mode and timestamp_to_int(entry.cmtime) != st.st_mtime_ns:
             files_cache_logger.debug('KNOWN-CHANGED: file mtime has changed: %r', hashed_path)
             return True, None
         # we ignored the inode number in the comparison above or it is still same.
@@ -1049,7 +1050,7 @@ class LocalCache(CacheStatsMixin):
         elif 'm' in cache_mode:
             cmtime_type = 'mtime'
             cmtime_ns = safe_ns(st.st_mtime_ns)
-        entry = FileCacheEntry(age=0, inode=st.st_ino, size=st.st_size, cmtime=int_to_bigint(cmtime_ns), chunk_ids=ids)
+        entry = FileCacheEntry(age=0, inode=st.st_ino, size=st.st_size, cmtime=int_to_timestamp(cmtime_ns), chunk_ids=ids)
         self.files[path_hash] = msgpack.packb(entry)
         self._newest_cmtime = max(self._newest_cmtime or 0, cmtime_ns)
         files_cache_logger.debug('FILES-CACHE-UPDATE: put %r [has %s] <- %r',
diff --git a/src/borg/helpers/msgpack.py b/src/borg/helpers/msgpack.py
index 2ace88fee..411f00fec 100644
--- a/src/borg/helpers/msgpack.py
+++ b/src/borg/helpers/msgpack.py
@@ -24,7 +24,7 @@ from msgpack import unpackb as mp_unpackb
 from msgpack import unpack as mp_unpack
 from msgpack import version as mp_version
 
-from msgpack import ExtType
+from msgpack import ExtType, Timestamp
 from msgpack import OutOfData
 
 
@@ -164,7 +164,7 @@ def get_limited_unpacker(kind):
     return Unpacker(**args)
 
 
-def bigint_to_int(mtime):
+def bigint_to_int(mtime):  # legacy
     """Convert bytearray to int
     """
     if isinstance(mtime, bytes):
@@ -172,7 +172,7 @@ def bigint_to_int(mtime):
     return mtime
 
 
-def int_to_bigint(value):
+def int_to_bigint(value):  # legacy
     """Convert integers larger than 64 bits to bytearray
 
     Smaller integers are left alone
@@ -180,3 +180,14 @@ def int_to_bigint(value):
     if value.bit_length() > 63:
         return value.to_bytes((value.bit_length() + 9) // 8, 'little', signed=True)
     return value
+
+
+def int_to_timestamp(ns):
+    return Timestamp.from_unix_nano(ns)
+
+
+def timestamp_to_int(ts):
+    if isinstance(ts, Timestamp):
+        return ts.to_unix_nano()
+    # legacy support note: we need to keep the bigint conversion for compatibility with borg < 1.3 archives.
+    return bigint_to_int(ts)
diff --git a/src/borg/helpers/parseformat.py b/src/borg/helpers/parseformat.py
index 3e145ada2..9bcbce22c 100644
--- a/src/borg/helpers/parseformat.py
+++ b/src/borg/helpers/parseformat.py
@@ -19,6 +19,7 @@ logger = create_logger()
 
 from .errors import Error
 from .fs import get_keys_dir
+from .msgpack import Timestamp
 from .time import OutputTimestamp, format_time, to_localtime, safe_timestamp, safe_s
 from .. import __version__ as borg_version
 from .. import __version_tuple__ as borg_version_tuple
@@ -1043,6 +1044,8 @@ def prepare_dump_dict(d):
                 value = decode_tuple(value)
             elif isinstance(value, bytes):
                 value = decode_bytes(value)
+            elif isinstance(value, Timestamp):
+                value = value.to_unix_nano()
             if isinstance(key, bytes):
                 key = key.decode()
             res[key] = value
diff --git a/src/borg/item.pyx b/src/borg/item.pyx
index 0b2598ffe..764279db0 100644
--- a/src/borg/item.pyx
+++ b/src/borg/item.pyx
@@ -3,9 +3,9 @@ from collections import namedtuple
 
 from .constants import ITEM_KEYS, ARCHIVE_KEYS
 from .helpers import safe_encode, safe_decode
-from .helpers import bigint_to_int, int_to_bigint
 from .helpers import StableDict
 from .helpers import format_file_size
+from .helpers.msgpack import timestamp_to_int, int_to_timestamp
 
 
 cdef extern from "_item.c":
@@ -171,11 +171,10 @@ class Item(PropDict):
     rdev = PropDict._make_property('rdev', int)
     bsdflags = PropDict._make_property('bsdflags', int)
 
-    # note: we need to keep the bigint conversion for compatibility with borg 1.0 archives.
-    atime = PropDict._make_property('atime', int, 'bigint', encode=int_to_bigint, decode=bigint_to_int)
-    ctime = PropDict._make_property('ctime', int, 'bigint', encode=int_to_bigint, decode=bigint_to_int)
-    mtime = PropDict._make_property('mtime', int, 'bigint', encode=int_to_bigint, decode=bigint_to_int)
-    birthtime = PropDict._make_property('birthtime', int, 'bigint', encode=int_to_bigint, decode=bigint_to_int)
+    atime = PropDict._make_property('atime', int, 'int (ns)', encode=int_to_timestamp, decode=timestamp_to_int)
+    ctime = PropDict._make_property('ctime', int, 'int (ns)', encode=int_to_timestamp, decode=timestamp_to_int)
+    mtime = PropDict._make_property('mtime', int, 'int (ns)', encode=int_to_timestamp, decode=timestamp_to_int)
+    birthtime = PropDict._make_property('birthtime', int, 'int (ns)', encode=int_to_timestamp, decode=timestamp_to_int)
 
     # size is only present for items with a chunk list and then it is sum(chunk_sizes)
     # compatibility note: this is a new feature, in old archives size will be missing.
diff --git a/src/borg/testsuite/item.py b/src/borg/testsuite/item.py
index aa40cc066..80b38edce 100644
--- a/src/borg/testsuite/item.py
+++ b/src/borg/testsuite/item.py
@@ -3,6 +3,7 @@ import pytest
 from ..cache import ChunkListEntry
 from ..item import Item
 from ..helpers import StableDict
+from ..helpers.msgpack import Timestamp
 
 
 def test_item_empty():
@@ -77,15 +78,15 @@ def test_item_int_property():
         item.mode = "invalid"
 
 
-def test_item_bigint_property():
+def test_item_mptimestamp_property():
     item = Item()
     small, big = 42, 2 ** 65
     item.atime = small
     assert item.atime == small
-    assert item.as_dict() == {'atime': small}
+    assert item.as_dict() == {'atime': Timestamp.from_unix_nano(small)}
     item.atime = big
     assert item.atime == big
-    assert item.as_dict() == {'atime': b'\0' * 8 + b'\x02'}
+    assert item.as_dict() == {'atime': Timestamp.from_unix_nano(big)}
 
 
 def test_item_user_group_none():

From 6bfdb3f63016a73b320c89fce4a80ca08e4ad49d Mon Sep 17 00:00:00 2001
From: Thomas Waldmann <tw@waldmann-edv.de>
Date: Sun, 8 May 2022 14:14:47 +0200
Subject: [PATCH 007/160] refactor hardlink_master processing globally

borg now has the chunks list in every item with content.
due to the symmetric way how borg now deals with hardlinks using
item.hlid, processing gets much simpler.

but some places where borg deals with other "sources" of hardlinks
still need to do some hardlink management:
borg uses the HardLinkManager there now (which is not much more
than a dict, but keeps documentation at one place and avoids some
code duplication we had before).

item.hlid is computed via hardlink_id function.

support hardlinked symlinks, fixes #2379
as we use item.hlid now to group hardlinks together,
there is no conflict with the item.source usage for
symlink targets any more.

2nd+ hardlinks now add to the files count as did the 1st one.
for borg, now all hardlinks are created equal.
so any hardlink item with chunks now adds to the "file" count.

ItemFormatter: support {hlid} instead of {source} for hardlinks
---
 docs/faq.rst                             |   3 -
 docs/internals/data-structures.rst       |   2 +-
 docs/usage/general/file-metadata.rst.inc |   2 +-
 src/borg/archive.py                      | 286 +++++++++--------------
 src/borg/archiver.py                     |  95 +++-----
 src/borg/fuse.py                         |  39 ++--
 src/borg/helpers/fs.py                   |  68 +++++-
 src/borg/helpers/parseformat.py          |  14 +-
 src/borg/item.pyx                        |   1 -
 src/borg/testsuite/archiver.py           |  44 +++-
 10 files changed, 263 insertions(+), 291 deletions(-)

diff --git a/docs/faq.rst b/docs/faq.rst
index 05f5176bc..d16eff6c0 100644
--- a/docs/faq.rst
+++ b/docs/faq.rst
@@ -132,9 +132,6 @@ Which file types, attributes, etc. are *not* preserved?
       Archive extraction has optional support to extract all-zero chunks as
       holes in a sparse file.
     * Some filesystem specific attributes, like btrfs NOCOW, see :ref:`platforms`.
-    * For hardlinked symlinks, the hardlinking can not be archived (and thus,
-      the hardlinking will not be done at extraction time). The symlinks will
-      be archived and extracted as non-hardlinked symlinks, see :issue:`2379`.
 
 Are there other known limitations?
 ----------------------------------
diff --git a/docs/internals/data-structures.rst b/docs/internals/data-structures.rst
index 2c5b7c194..d1a5a4cd3 100644
--- a/docs/internals/data-structures.rst
+++ b/docs/internals/data-structures.rst
@@ -567,7 +567,7 @@ dictionary created by the ``Item`` class that contains:
 * uid
 * gid
 * mode (item type + permissions)
-* source (for symlinks, and for hardlinks within one archive)
+* source (for symlinks)
 * rdev (for device files)
 * mtime, atime, ctime in nanoseconds
 * xattrs
diff --git a/docs/usage/general/file-metadata.rst.inc b/docs/usage/general/file-metadata.rst.inc
index 8f4c67cbf..c2694d188 100644
--- a/docs/usage/general/file-metadata.rst.inc
+++ b/docs/usage/general/file-metadata.rst.inc
@@ -10,7 +10,7 @@ Besides regular file and directory structures, Borg can preserve
   * FIFOs ("named pipes")
   * special file *contents* can be backed up in ``--read-special`` mode.
     By default the metadata to create them with mknod(2), mkfifo(2) etc. is stored.
-* hardlinked regular files, devices, FIFOs (considering all items in the same archive)
+* hardlinked regular files, devices, symlinks, FIFOs (considering all items in the same archive)
 * timestamps in nanosecond precision: mtime, atime, ctime
 * other timestamps: birthtime (on platforms supporting it)
 * permissions:
diff --git a/src/borg/archive.py b/src/borg/archive.py
index ba95a0867..da083eac6 100644
--- a/src/borg/archive.py
+++ b/src/borg/archive.py
@@ -28,7 +28,7 @@ from .constants import *  # NOQA
 from .crypto.low_level import IntegrityError as IntegrityErrorBase
 from .hashindex import ChunkIndex, ChunkIndexEntry, CacheSynchronizer
 from .helpers import Manifest
-from .helpers import hardlinkable
+from .helpers import HardLinkManager
 from .helpers import ChunkIteratorFileWrapper, open_item
 from .helpers import Error, IntegrityError, set_ec
 from .platform import uid2user, user2uid, gid2group, group2gid
@@ -280,7 +280,7 @@ class DownloadPipeline:
         self.repository = repository
         self.key = key
 
-    def unpack_many(self, ids, filter=None, partial_extract=False, preload=False, hardlink_masters=None):
+    def unpack_many(self, ids, *, filter=None, preload=False):
         """
         Return iterator of items.
 
@@ -290,10 +290,7 @@ class DownloadPipeline:
         Warning: if *preload* is True then all data chunks of every yielded item have to be retrieved,
         otherwise preloaded chunks will accumulate in RemoteRepository and create a memory leak.
         """
-        def _preload(chunks):
-            self.repository.preload([c.id for c in chunks])
-
-        masters_preloaded = set()
+        hlids_preloaded = set()
         unpacker = msgpack.Unpacker(use_list=False)
         for data in self.fetch_many(ids):
             unpacker.feed(data)
@@ -306,33 +303,20 @@ class DownloadPipeline:
                 items = [item for item in items if filter(item)]
 
             if preload:
-                if filter and partial_extract:
-                    # if we do only a partial extraction, it gets a bit
-                    # complicated with computing the preload items: if a hardlink master item is not
-                    # selected (== not extracted), we will still need to preload its chunks if a
-                    # corresponding hardlink slave is selected (== is extracted).
-                    # due to a side effect of the filter() call, we now have hardlink_masters dict populated.
-                    for item in items:
-                        if hardlinkable(item.mode):
-                            source = item.get('source')
-                            if source is None:  # maybe a hardlink master
-                                if 'chunks' in item:
-                                    _preload(item.chunks)
-                                # if this is a hl master, remember that we already preloaded all chunks of it (if any):
-                                if item.get('hardlink_master', True):
-                                    masters_preloaded.add(item.path)
-                            else:  # hardlink slave
-                                if source not in masters_preloaded:
-                                    # we only need to preload *once* (for the 1st selected slave)
-                                    chunks, _ = hardlink_masters[source]
-                                    if chunks is not None:
-                                        _preload(chunks)
-                                    masters_preloaded.add(source)
-                else:
-                    # easy: we do not have a filter, thus all items are selected, thus we need to preload all chunks.
-                    for item in items:
-                        if 'chunks' in item:
-                            _preload(item.chunks)
+                for item in items:
+                    if 'chunks' in item:
+                        hlid = item.get('hlid', None)
+                        if hlid is None:
+                            preload_chunks = True
+                        else:
+                            if hlid in hlids_preloaded:
+                                preload_chunks = False
+                            else:
+                                # not having the hardlink's chunks already preloaded for other hardlink to same inode
+                                preload_chunks = True
+                                hlids_preloaded.add(hlid)
+                        if preload_chunks:
+                            self.repository.preload([c.id for c in item.chunks])
 
             for item in items:
                 yield item
@@ -443,7 +427,6 @@ class Archive:
         self.repository = repository
         self.cache = cache
         self.manifest = manifest
-        self.hard_links = {}
         self.stats = Statistics(output_json=log_json, iec=iec)
         self.iec = iec
         self.show_progress = progress
@@ -584,12 +567,10 @@ Utilization of max. archive size: {csize_max:.0%}
             return False
         return filter(item) if filter else True
 
-    def iter_items(self, filter=None, partial_extract=False, preload=False, hardlink_masters=None):
+    def iter_items(self, filter=None, preload=False):
         # note: when calling this with preload=True, later fetch_many() must be called with
         # is_preloaded=True or the RemoteRepository code will leak memory!
-        assert not (filter and partial_extract and preload) or hardlink_masters is not None
-        for item in self.pipeline.unpack_many(self.metadata.items, partial_extract=partial_extract,
-                                              preload=preload, hardlink_masters=hardlink_masters,
+        for item in self.pipeline.unpack_many(self.metadata.items, preload=preload,
                                               filter=lambda item: self.item_filter(item, filter)):
             yield item
 
@@ -719,33 +700,30 @@ Utilization of max. archive size: {csize_max:.0%}
         return stats
 
     @contextmanager
-    def extract_helper(self, dest, item, path, stripped_components, original_path, hardlink_masters):
+    def extract_helper(self, item, path, hlm, *, dry_run=False):
         hardlink_set = False
         # Hard link?
-        if 'source' in item:
-            source = os.path.join(dest, *item.source.split(os.sep)[stripped_components:])
-            chunks, link_target = hardlink_masters.get(item.source, (None, source))
-            if link_target and has_link:
-                # Hard link was extracted previously, just link
-                with backup_io('link'):
-                    os.link(link_target, path)
-                    hardlink_set = True
-            elif chunks is not None:
-                # assign chunks to this item, since the item which had the chunks was not extracted
-                item.chunks = chunks
+        if 'hlid' in item:
+            link_target = hlm.retrieve(id=item.hlid)
+            if link_target is not None and has_link:
+                if not dry_run:
+                    # another hardlink to same inode (same hlid) was extracted previously, just link to it
+                    with backup_io('link'):
+                        os.link(link_target, path, follow_symlinks=False)
+                hardlink_set = True
         yield hardlink_set
-        if not hardlink_set and hardlink_masters:
-            if has_link:
-                # Update master entry with extracted item path, so that following hardlinks don't extract twice.
+        if not hardlink_set:
+            if 'hlid' in item and has_link:
+                # Update entry with extracted item path, so that following hardlinks don't extract twice.
                 # We have hardlinking support, so we will hardlink not extract.
-                hardlink_masters[item.get('source') or original_path] = (None, path)
+                hlm.remember(id=item.hlid, info=path)
             else:
                 # Broken platform with no hardlinking support.
                 # In this case, we *want* to extract twice, because there is no other way.
                 pass
 
     def extract_item(self, item, restore_attrs=True, dry_run=False, stdout=False, sparse=False,
-                     hardlink_masters=None, stripped_components=0, original_path=None, pi=None):
+                     hlm=None, stripped_components=0, original_path=None, pi=None):
         """
         Extract archive item.
 
@@ -754,29 +732,33 @@ Utilization of max. archive size: {csize_max:.0%}
         :param dry_run: do not write any data
         :param stdout: write extracted data to stdout
         :param sparse: write sparse files (chunk-granularity, independent of the original being sparse)
-        :param hardlink_masters: maps paths to (chunks, link_target) for extracting subtrees with hardlinks correctly
+        :param hlm: maps hlid to link_target for extracting subtrees with hardlinks correctly
         :param stripped_components: stripped leading path components to correct hard link extraction
         :param original_path: 'path' key as stored in archive
         :param pi: ProgressIndicatorPercent (or similar) for file extraction progress (in bytes)
         """
-        hardlink_masters = hardlink_masters or {}
         has_damaged_chunks = 'chunks_healthy' in item
         if dry_run or stdout:
-            if 'chunks' in item:
-                item_chunks_size = 0
-                for data in self.pipeline.fetch_many([c.id for c in item.chunks], is_preloaded=True):
-                    if pi:
-                        pi.show(increase=len(data), info=[remove_surrogates(item.path)])
-                    if stdout:
-                        sys.stdout.buffer.write(data)
-                    item_chunks_size += len(data)
-                if stdout:
-                    sys.stdout.buffer.flush()
-                if 'size' in item:
-                    item_size = item.size
-                    if item_size != item_chunks_size:
-                        raise BackupError('Size inconsistency detected: size {}, chunks size {}'.format(
-                                          item_size, item_chunks_size))
+            with self.extract_helper(item, '', hlm, dry_run=dry_run or stdout) as hardlink_set:
+                if not hardlink_set:
+                    # it does not really set hardlinks due to dry_run, but we need to behave same
+                    # as non-dry_run concerning fetching preloaded chunks from the pipeline or
+                    # it would get stuck.
+                    if 'chunks' in item:
+                        item_chunks_size = 0
+                        for data in self.pipeline.fetch_many([c.id for c in item.chunks], is_preloaded=True):
+                            if pi:
+                                pi.show(increase=len(data), info=[remove_surrogates(item.path)])
+                            if stdout:
+                                sys.stdout.buffer.write(data)
+                            item_chunks_size += len(data)
+                        if stdout:
+                            sys.stdout.buffer.flush()
+                        if 'size' in item:
+                            item_size = item.size
+                            if item_size != item_chunks_size:
+                                raise BackupError('Size inconsistency detected: size {}, chunks size {}'.format(
+                                                  item_size, item_chunks_size))
             if has_damaged_chunks:
                 raise BackupError('File has damaged (all-zero) chunks. Try running borg check --repair.')
             return
@@ -807,8 +789,7 @@ Utilization of max. archive size: {csize_max:.0%}
         if stat.S_ISREG(mode):
             with backup_io('makedirs'):
                 make_parent(path)
-            with self.extract_helper(dest, item, path, stripped_components, original_path,
-                                     hardlink_masters) as hardlink_set:
+            with self.extract_helper(item, path, hlm) as hardlink_set:
                 if hardlink_set:
                     return
                 with backup_io('open'):
@@ -847,24 +828,26 @@ Utilization of max. archive size: {csize_max:.0%}
                     self.restore_attrs(path, item)
             elif stat.S_ISLNK(mode):
                 make_parent(path)
-                source = item.source
-                try:
-                    os.symlink(source, path)
-                except UnicodeEncodeError:
-                    raise self.IncompatibleFilesystemEncodingError(source, sys.getfilesystemencoding()) from None
-                self.restore_attrs(path, item, symlink=True)
+                with self.extract_helper(item, path, hlm) as hardlink_set:
+                    if hardlink_set:
+                        # unusual, but possible: this is a hardlinked symlink.
+                        return
+                    source = item.source
+                    try:
+                        os.symlink(source, path)
+                    except UnicodeEncodeError:
+                        raise self.IncompatibleFilesystemEncodingError(source, sys.getfilesystemencoding()) from None
+                    self.restore_attrs(path, item, symlink=True)
             elif stat.S_ISFIFO(mode):
                 make_parent(path)
-                with self.extract_helper(dest, item, path, stripped_components, original_path,
-                                         hardlink_masters) as hardlink_set:
+                with self.extract_helper(item, path, hlm) as hardlink_set:
                     if hardlink_set:
                         return
                     os.mkfifo(path)
                     self.restore_attrs(path, item)
             elif stat.S_ISCHR(mode) or stat.S_ISBLK(mode):
                 make_parent(path)
-                with self.extract_helper(dest, item, path, stripped_components, original_path,
-                                         hardlink_masters) as hardlink_set:
+                with self.extract_helper(item, path, hlm) as hardlink_set:
                     if hardlink_set:
                         return
                     os.mknod(path, item.mode, item.rdev)
@@ -1041,79 +1024,43 @@ Utilization of max. archive size: {csize_max:.0%}
         :param can_compare_chunk_ids: Whether --chunker-params are the same for both archives.
         """
 
-        def hardlink_master_seen(item):
-            return 'source' not in item or not hardlinkable(item.mode) or item.source in hardlink_masters
-
-        def is_hardlink_master(item):
-            return item.get('hardlink_master', True) and 'source' not in item and hardlinkable(item.mode)
-
-        def update_hardlink_masters(item1, item2):
-            if is_hardlink_master(item1) or is_hardlink_master(item2):
-                hardlink_masters[item1.path] = (item1, item2)
-
-        def has_hardlink_master(item, hardlink_masters):
-            return hardlinkable(item.mode) and item.get('source') in hardlink_masters
-
         def compare_items(item1, item2):
-            if has_hardlink_master(item1, hardlink_masters):
-                item1 = hardlink_masters[item1.source][0]
-            if has_hardlink_master(item2, hardlink_masters):
-                item2 = hardlink_masters[item2.source][1]
             return ItemDiff(item1, item2,
                             archive1.pipeline.fetch_many([c.id for c in item1.get('chunks', [])]),
                             archive2.pipeline.fetch_many([c.id for c in item2.get('chunks', [])]),
                             can_compare_chunk_ids=can_compare_chunk_ids)
 
-        def defer_if_necessary(item1, item2):
-            """Adds item tuple to deferred if necessary and returns True, if items were deferred"""
-            update_hardlink_masters(item1, item2)
-            defer = not hardlink_master_seen(item1) or not hardlink_master_seen(item2)
-            if defer:
-                deferred.append((item1, item2))
-            return defer
-
         orphans_archive1 = OrderedDict()
         orphans_archive2 = OrderedDict()
-        deferred = []
-        hardlink_masters = {}
 
         for item1, item2 in zip_longest(
                 archive1.iter_items(lambda item: matcher.match(item.path)),
                 archive2.iter_items(lambda item: matcher.match(item.path)),
         ):
             if item1 and item2 and item1.path == item2.path:
-                if not defer_if_necessary(item1, item2):
-                    yield (item1.path, compare_items(item1, item2))
+                yield (item1.path, compare_items(item1, item2))
                 continue
             if item1:
                 matching_orphan = orphans_archive2.pop(item1.path, None)
                 if matching_orphan:
-                    if not defer_if_necessary(item1, matching_orphan):
-                        yield (item1.path, compare_items(item1, matching_orphan))
+                    yield (item1.path, compare_items(item1, matching_orphan))
                 else:
                     orphans_archive1[item1.path] = item1
             if item2:
                 matching_orphan = orphans_archive1.pop(item2.path, None)
                 if matching_orphan:
-                    if not defer_if_necessary(matching_orphan, item2):
-                        yield (matching_orphan.path, compare_items(matching_orphan, item2))
+                    yield (matching_orphan.path, compare_items(matching_orphan, item2))
                 else:
                     orphans_archive2[item2.path] = item2
         # At this point orphans_* contain items that had no matching partner in the other archive
         for added in orphans_archive2.values():
             path = added.path
             deleted_item = Item.create_deleted(path)
-            update_hardlink_masters(deleted_item, added)
             yield (path, compare_items(deleted_item, added))
         for deleted in orphans_archive1.values():
             path = deleted.path
             deleted_item = Item.create_deleted(path)
-            update_hardlink_masters(deleted, deleted_item)
             yield (path, compare_items(deleted, deleted_item))
-        for item1, item2 in deferred:
-            assert hardlink_master_seen(item1)
-            assert hardlink_master_seen(item2)
-            yield (path, compare_items(item1, item2))
 
 
 class MetadataCollector:
@@ -1289,7 +1236,7 @@ class FilesystemObjectProcessors:
         self.show_progress = show_progress
         self.print_file_status = file_status_printer or (lambda *args: None)
 
-        self.hard_links = {}
+        self.hlm = HardLinkManager(id_type=tuple, info_type=tuple)  # (dev, ino) -> (hlid, chunks)
         self.stats = Statistics(output_json=log_json, iec=iec)  # threading: done by cache (including progress)
         self.cwd = os.getcwd()
         self.chunker = get_chunker(*chunker_params, seed=key.chunk_seed, sparse=sparse)
@@ -1298,29 +1245,32 @@ class FilesystemObjectProcessors:
     def create_helper(self, path, st, status=None, hardlinkable=True):
         safe_path = make_path_safe(path)
         item = Item(path=safe_path)
-        hardlink_master = False
         hardlinked = hardlinkable and st.st_nlink > 1
+        update_map = False
         if hardlinked:
-            source = self.hard_links.get((st.st_ino, st.st_dev))
-            if source is not None:
-                item.source = source
-                status = 'h'  # hardlink (to already seen inodes)
-            else:
-                hardlink_master = True
-        yield item, status, hardlinked, hardlink_master
-        # if we get here, "with"-block worked ok without error/exception, the item was processed ok...
+            status = 'h'  # hardlink
+            hlid, chunks = self.hlm.retrieve(id=(st.st_ino, st.st_dev), default=(None, None))
+            if hlid is None:
+                update_map = True
+                hlid = self.hlm.hardlink_id(item._dict['path'])
+            item.hlid = hlid
+            if chunks is not None:
+                item.chunks = chunks
+        yield item, status, hardlinked
         self.add_item(item, stats=self.stats)
-        # ... and added to the archive, so we can remember it to refer to it later in the archive:
-        if hardlink_master:
-            self.hard_links[(st.st_ino, st.st_dev)] = safe_path
+        if update_map:
+            # remember the hlid of this fs object and if the item has chunks,
+            # also remember them, so we do not have to re-chunk a hardlink.
+            chunks = item.chunks if 'chunks' in item else None
+            self.hlm.remember(id=(st.st_ino, st.st_dev), info=(hlid, chunks))
 
     def process_dir_with_fd(self, *, path, fd, st):
-        with self.create_helper(path, st, 'd', hardlinkable=False) as (item, status, hardlinked, hardlink_master):
+        with self.create_helper(path, st, 'd', hardlinkable=False) as (item, status, hardlinked):
             item.update(self.metadata_collector.stat_attrs(st, path, fd=fd))
             return status
 
     def process_dir(self, *, path, parent_fd, name, st):
-        with self.create_helper(path, st, 'd', hardlinkable=False) as (item, status, hardlinked, hardlink_master):
+        with self.create_helper(path, st, 'd', hardlinkable=False) as (item, status, hardlinked):
             with OsOpen(path=path, parent_fd=parent_fd, name=name, flags=flags_dir,
                         noatime=True, op='dir_open') as fd:
                 # fd is None for directories on windows, in that case a race condition check is not possible.
@@ -1331,7 +1281,7 @@ class FilesystemObjectProcessors:
                 return status
 
     def process_fifo(self, *, path, parent_fd, name, st):
-        with self.create_helper(path, st, 'f') as (item, status, hardlinked, hardlink_master):  # fifo
+        with self.create_helper(path, st, 'f') as (item, status, hardlinked):  # fifo
             with OsOpen(path=path, parent_fd=parent_fd, name=name, flags=flags_normal, noatime=True) as fd:
                 with backup_io('fstat'):
                     st = stat_update_check(st, os.fstat(fd))
@@ -1339,7 +1289,7 @@ class FilesystemObjectProcessors:
                 return status
 
     def process_dev(self, *, path, parent_fd, name, st, dev_type):
-        with self.create_helper(path, st, dev_type) as (item, status, hardlinked, hardlink_master):  # char/block device
+        with self.create_helper(path, st, dev_type) as (item, status, hardlinked):  # char/block device
             # looks like we can not work fd-based here without causing issues when trying to open/close the device
             with backup_io('stat'):
                 st = stat_update_check(st, os_stat(path=path, parent_fd=parent_fd, name=name, follow_symlinks=False))
@@ -1348,10 +1298,7 @@ class FilesystemObjectProcessors:
             return status
 
     def process_symlink(self, *, path, parent_fd, name, st):
-        # note: using hardlinkable=False because we can not support hardlinked symlinks,
-        #       due to the dual-use of item.source, see issue #2343:
-        # hardlinked symlinks will be archived [and extracted] as non-hardlinked symlinks.
-        with self.create_helper(path, st, 's', hardlinkable=False) as (item, status, hardlinked, hardlink_master):
+        with self.create_helper(path, st, 's', hardlinkable=True) as (item, status, hardlinked):
             fname = name if name is not None and parent_fd is not None else path
             with backup_io('readlink'):
                 source = os.readlink(fname, dir_fd=parent_fd)
@@ -1384,7 +1331,7 @@ class FilesystemObjectProcessors:
         return status
 
     def process_file(self, *, path, parent_fd, name, st, cache, flags=flags_normal):
-        with self.create_helper(path, st, None) as (item, status, hardlinked, hardlink_master):  # no status yet
+        with self.create_helper(path, st, None) as (item, status, hardlinked):  # no status yet
             with OsOpen(path=path, parent_fd=parent_fd, name=name, flags=flags, noatime=True) as fd:
                 with backup_io('fstat'):
                     st = stat_update_check(st, os.fstat(fd))
@@ -1395,7 +1342,9 @@ class FilesystemObjectProcessors:
                     # so it can be extracted / accessed in FUSE mount like a regular file.
                     # this needs to be done early, so that part files also get the patched mode.
                     item.mode = stat.S_IFREG | stat.S_IMODE(item.mode)
-                if not hardlinked or hardlink_master:
+                if 'chunks' in item:  # create_helper might have put chunks from a previous hardlink there
+                    [cache.chunk_incref(id_, self.stats) for id_, _, _ in item.chunks]
+                else:  # normal case, no "2nd+" hardlink
                     if not is_special_file:
                         hashed_path = safe_encode(os.path.join(self.cwd, path))
                         path_hash = self.key.id_hash(hashed_path)
@@ -1420,7 +1369,6 @@ class FilesystemObjectProcessors:
                         status = 'M' if known else 'A'  # regular file, modified or added
                     self.print_file_status(status, path)
                     status = None  # we already printed the status
-                    item.hardlink_master = hardlinked
                     # Only chunkify the file if needed
                     if chunks is not None:
                         item.chunks = chunks
@@ -1444,7 +1392,7 @@ class FilesystemObjectProcessors:
                             # also, we must not memorize a potentially inconsistent/corrupt file that
                             # changed while we backed it up.
                             cache.memorize_file(hashed_path, path_hash, st, [c.id for c in item.chunks])
-                    self.stats.nfiles += 1
+                self.stats.nfiles += 1
                 item.update(self.metadata_collector.stat_ext_attrs(st, path, fd=fd))
                 item.get_size(memorize=True)
                 return status
@@ -1464,6 +1412,7 @@ class TarfileObjectProcessors:
 
         self.stats = Statistics(output_json=log_json, iec=iec)  # threading: done by cache (including progress)
         self.chunker = get_chunker(*chunker_params, seed=key.chunk_seed, sparse=False)
+        self.hlm = HardLinkManager(id_type=str, info_type=list)  # path -> chunks
 
     @contextmanager
     def create_helper(self, tarinfo, status=None, type=None):
@@ -1504,11 +1453,21 @@ class TarfileObjectProcessors:
             item.rdev = os.makedev(tarinfo.devmajor, tarinfo.devminor)
             return status
 
-    def process_link(self, *, tarinfo, status, type):
+    def process_symlink(self, *, tarinfo, status, type):
         with self.create_helper(tarinfo, status, type) as (item, status):
             item.source = tarinfo.linkname
             return status
 
+    def process_hardlink(self, *, tarinfo, status, type):
+        with self.create_helper(tarinfo, status, type) as (item, status):
+            # create a not hardlinked borg item, reusing the chunks, see HardLinkManager.__doc__
+            chunks = self.hlm.retrieve(tarinfo.linkname)
+            if chunks is not None:
+                item.chunks = chunks
+            item.get_size(memorize=True, from_chunks=True)
+            self.stats.nfiles += 1
+            return status
+
     def process_file(self, *, tarinfo, status, type, tar):
         with self.create_helper(tarinfo, status, type) as (item, status):
             self.print_file_status(status, tarinfo.name)
@@ -1516,8 +1475,10 @@ class TarfileObjectProcessors:
             fd = tar.extractfile(tarinfo)
             self.process_file_chunks(item, self.cache, self.stats, self.show_progress,
                                      backup_io_iter(self.chunker.chunkify(fd)))
-            item.get_size(memorize=True)
+            item.get_size(memorize=True, from_chunks=True)
             self.stats.nfiles += 1
+            # we need to remember ALL files, see HardLinkManager.__doc__
+            self.hlm.remember(id=tarinfo.name, info=item.chunks)
             return status
 
 
@@ -2127,34 +2088,11 @@ class ArchiveRecreater:
 
     def process_items(self, archive, target):
         matcher = self.matcher
-        target_is_subset = not matcher.empty()
-        hardlink_masters = {} if target_is_subset else None
-
-        def item_is_hardlink_master(item):
-            return (target_is_subset and
-                    hardlinkable(item.mode) and
-                    item.get('hardlink_master', True) and
-                    'source' not in item)
 
         for item in archive.iter_items():
             if not matcher.match(item.path):
                 self.print_file_status('x', item.path)
-                if item_is_hardlink_master(item):
-                    hardlink_masters[item.path] = (item.get('chunks'), item.get('chunks_healthy'), None)
                 continue
-            if target_is_subset and hardlinkable(item.mode) and item.get('source') in hardlink_masters:
-                # master of this hard link is outside the target subset
-                chunks, chunks_healthy, new_source = hardlink_masters[item.source]
-                if new_source is None:
-                    # First item to use this master, move the chunks
-                    item.chunks = chunks
-                    if chunks_healthy is not None:
-                        item.chunks_healthy = chunks_healthy
-                    hardlink_masters[item.source] = (None, None, item.path)
-                    del item.source
-                else:
-                    # Master was already moved, only update this item's source
-                    item.source = new_source
             if self.dry_run:
                 self.print_file_status('-', item.path)
             else:
@@ -2261,7 +2199,7 @@ class ArchiveRecreater:
         tag_files = []
         tagged_dirs = []
 
-        # to support reading hard-linked CACHEDIR.TAGs (aka CACHE_TAG_NAME), similar to hardlink_masters:
+        # to support reading hard-linked CACHEDIR.TAGs (aka CACHE_TAG_NAME):
         cachedir_masters = {}
 
         if self.exclude_caches:
diff --git a/src/borg/archiver.py b/src/borg/archiver.py
index eac059bb7..4b6fd1782 100644
--- a/src/borg/archiver.py
+++ b/src/borg/archiver.py
@@ -59,7 +59,7 @@ try:
     from .helpers import timestamp
     from .helpers import get_cache_dir, os_stat
     from .helpers import Manifest, AI_HUMAN_SORT_KEYS
-    from .helpers import hardlinkable
+    from .helpers import HardLinkManager
     from .helpers import StableDict
     from .helpers import check_python, check_extension_modules
     from .helpers import dir_is_tagged, is_slow_msgpack, is_supported_msgpack, yes, sysinfo
@@ -347,12 +347,12 @@ class Archiver:
 
         def upgrade_item(item):
             """upgrade item as needed, get rid of legacy crap"""
-            if item.get('hardlink_master', True) and 'source' not in item and hardlinkable(item.mode):
-                item._dict['hlid'] = hlid = hashlib.sha256(item._dict['path'])
-                hardlink_masters[hlid] = (item._dict.get('chunks'), item._dict.get('chunks_healthy'))
-            elif 'source' in item and hardlinkable(item.mode):
-                item._dict['hlid'] = hlid = hashlib.sha256(item._dict['source'])
-                chunks, chunks_healthy = hardlink_masters.get(hlid, (None, None))
+            if hlm.borg1_hardlink_master(item):
+                item._dict['hlid'] = hlid = hlm.hardlink_id(item._dict['path'])
+                hlm.remember(id=hlid, info=(item._dict.get('chunks'), item._dict.get('chunks_healthy')))
+            elif hlm.borg1_hardlink_slave(item):
+                item._dict['hlid'] = hlid = hlm.hardlink_id(item._dict['source'])
+                chunks, chunks_healthy = hlm.retrieve(id=hlid, default=(None, None))
                 if chunks is not None:
                     item._dict['chunks'] = chunks
                     for chunk_id, _, _ in chunks:
@@ -389,7 +389,7 @@ class Archiver:
             else:
                 if not dry_run:
                     print(f"{name}: copying archive to destination repo...")
-                hardlink_masters = {}
+                hlm = HardLinkManager(id_type=bytes, info_type=tuple)  # hlid -> (chunks, chunks_healthy)
                 other_archive = Archive(other_repository, other_key, other_manifest, name)
                 archive = Archive(repository, key, manifest, name, cache=cache, create=True) if not dry_run else None
                 for item in other_archive.iter_items():
@@ -1154,16 +1154,14 @@ class Archiver:
             self.print_file_status(status, path)
 
     @staticmethod
-    def build_filter(matcher, peek_and_store_hardlink_masters, strip_components):
+    def build_filter(matcher, strip_components):
         if strip_components:
             def item_filter(item):
                 matched = matcher.match(item.path) and os.sep.join(item.path.split(os.sep)[strip_components:])
-                peek_and_store_hardlink_masters(item, matched)
                 return matched
         else:
             def item_filter(item):
                 matched = matcher.match(item.path)
-                peek_and_store_hardlink_masters(item, matched)
                 return matched
         return item_filter
 
@@ -1186,33 +1184,18 @@ class Archiver:
         sparse = args.sparse
         strip_components = args.strip_components
         dirs = []
-        partial_extract = not matcher.empty() or strip_components
-        hardlink_masters = {} if partial_extract or not has_link else None
+        hlm = HardLinkManager(id_type=bytes, info_type=str)  # hlid -> path
 
-        def peek_and_store_hardlink_masters(item, matched):
-            # not has_link:
-            # OS does not have hardlink capability thus we need to remember the chunks so that
-            # we can extract all hardlinks as separate normal (not-hardlinked) files instead.
-            #
-            # partial_extract and not matched and hardlinkable:
-            # we do not extract the very first hardlink, so we need to remember the chunks
-            # in hardlinks_master, so we can use them when we extract some 2nd+ hardlink item
-            # that has no chunks list.
-            if ((not has_link or (partial_extract and not matched and hardlinkable(item.mode))) and
-                    (item.get('hardlink_master', True) and 'source' not in item)):
-                hardlink_masters[item.get('path')] = (item.get('chunks'), None)
-
-        filter = self.build_filter(matcher, peek_and_store_hardlink_masters, strip_components)
+        filter = self.build_filter(matcher, strip_components)
         if progress:
             pi = ProgressIndicatorPercent(msg='%5.1f%% Extracting: %s', step=0.1, msgid='extract')
             pi.output('Calculating total archive size for the progress indicator (might take long for large archives)')
-            extracted_size = sum(item.get_size(hardlink_masters) for item in archive.iter_items(filter))
+            extracted_size = sum(item.get_size() for item in archive.iter_items(filter))
             pi.total = extracted_size
         else:
             pi = None
 
-        for item in archive.iter_items(filter, partial_extract=partial_extract,
-                                       preload=True, hardlink_masters=hardlink_masters):
+        for item in archive.iter_items(filter, preload=True):
             orig_path = item.path
             if strip_components:
                 item.path = os.sep.join(orig_path.split(os.sep)[strip_components:])
@@ -1227,13 +1210,13 @@ class Archiver:
                 logging.getLogger('borg.output.list').info(remove_surrogates(item.path))
             try:
                 if dry_run:
-                    archive.extract_item(item, dry_run=True, pi=pi)
+                    archive.extract_item(item, dry_run=True, hlm=hlm, pi=pi)
                 else:
                     if stat.S_ISDIR(item.mode):
                         dirs.append(item)
                         archive.extract_item(item, stdout=stdout, restore_attrs=False)
                     else:
-                        archive.extract_item(item, stdout=stdout, sparse=sparse, hardlink_masters=hardlink_masters,
+                        archive.extract_item(item, stdout=stdout, sparse=sparse, hlm=hlm,
                                              stripped_components=strip_components, original_path=orig_path, pi=pi)
             except (BackupOSError, BackupError) as e:
                 self.print_warning('%s: %s', remove_surrogates(orig_path), e)
@@ -1298,15 +1281,9 @@ class Archiver:
         progress = args.progress
         output_list = args.output_list
         strip_components = args.strip_components
-        partial_extract = not matcher.empty() or strip_components
-        hardlink_masters = {} if partial_extract else None
+        hlm = HardLinkManager(id_type=bytes, info_type=str)  # hlid -> path
 
-        def peek_and_store_hardlink_masters(item, matched):
-            if ((partial_extract and not matched and hardlinkable(item.mode)) and
-                    (item.get('hardlink_master', True) and 'source' not in item)):
-                hardlink_masters[item.get('path')] = (item.get('chunks'), None)
-
-        filter = self.build_filter(matcher, peek_and_store_hardlink_masters, strip_components)
+        filter = self.build_filter(matcher, strip_components)
 
         # The | (pipe) symbol instructs tarfile to use a streaming mode of operation
         # where it never seeks on the passed fileobj.
@@ -1316,7 +1293,7 @@ class Archiver:
         if progress:
             pi = ProgressIndicatorPercent(msg='%5.1f%% Processing: %s', step=0.1, msgid='extract')
             pi.output('Calculating size')
-            extracted_size = sum(item.get_size(hardlink_masters) for item in archive.iter_items(filter))
+            extracted_size = sum(item.get_size() for item in archive.iter_items(filter))
             pi.total = extracted_size
         else:
             pi = None
@@ -1351,9 +1328,8 @@ class Archiver:
             tarinfo.gid = item.gid
             tarinfo.uname = item.user or ''
             tarinfo.gname = item.group or ''
-            # The linkname in tar has the same dual use the 'source' attribute of Borg items,
-            # i.e. for symlinks it means the destination, while for hardlinks it refers to the
-            # file.
+            # The linkname in tar has 2 uses:
+            # for symlinks it means the destination, while for hardlinks it refers to the file.
             # Since hardlinks in tar have a different type code (LNKTYPE) the format might
             # support hardlinking arbitrary objects (including symlinks and directories), but
             # whether implementations actually support that is a whole different question...
@@ -1362,23 +1338,16 @@ class Archiver:
             modebits = stat.S_IFMT(item.mode)
             if modebits == stat.S_IFREG:
                 tarinfo.type = tarfile.REGTYPE
-                if 'source' in item:
-                    source = os.sep.join(item.source.split(os.sep)[strip_components:])
-                    if hardlink_masters is None:
-                        linkname = source
-                    else:
-                        chunks, linkname = hardlink_masters.get(item.source, (None, source))
-                    if linkname:
-                        # Master was already added to the archive, add a hardlink reference to it.
+                if 'hlid' in item:
+                    linkname = hlm.retrieve(id=item.hlid)
+                    if linkname is not None:
+                        # the first hardlink was already added to the archive, add a tar-hardlink reference to it.
                         tarinfo.type = tarfile.LNKTYPE
                         tarinfo.linkname = linkname
-                    elif chunks is not None:
-                        # The item which has the chunks was not put into the tar, therefore
-                        # we do that now and update hardlink_masters to reflect that.
-                        item.chunks = chunks
+                    else:
                         tarinfo.size = item.get_size()
                         stream = item_content_stream(item)
-                        hardlink_masters[item.get('source') or original_path] = (None, item.path)
+                        hlm.remember(id=item.hlid, info=item.path)
                 else:
                     tarinfo.size = item.get_size()
                     stream = item_content_stream(item)
@@ -1436,8 +1405,7 @@ class Archiver:
                 ph['BORG.item.meta'] = meta_text
             return ph
 
-        for item in archive.iter_items(filter, partial_extract=partial_extract,
-                                       preload=True, hardlink_masters=hardlink_masters):
+        for item in archive.iter_items(filter, preload=True):
             orig_path = item.path
             if strip_components:
                 item.path = os.sep.join(orig_path.split(os.sep)[strip_components:])
@@ -2072,12 +2040,11 @@ class Archiver:
             elif tarinfo.isdir():
                 status = tfo.process_dir(tarinfo=tarinfo, status='d', type=stat.S_IFDIR)
             elif tarinfo.issym():
-                status = tfo.process_link(tarinfo=tarinfo, status='s', type=stat.S_IFLNK)
+                status = tfo.process_symlink(tarinfo=tarinfo, status='s', type=stat.S_IFLNK)
             elif tarinfo.islnk():
-                # tar uses the same hardlink model as borg (rather vice versa); the first instance of a hardlink
-                # is stored as a regular file, later instances are special entries referencing back to the
-                # first instance.
-                status = tfo.process_link(tarinfo=tarinfo, status='h', type=stat.S_IFREG)
+                # tar uses a hardlink model like: the first instance of a hardlink is stored as a regular file,
+                # later instances are special entries referencing back to the first instance.
+                status = tfo.process_hardlink(tarinfo=tarinfo, status='h', type=stat.S_IFREG)
             elif tarinfo.isblk():
                 status = tfo.process_dev(tarinfo=tarinfo, status='b', type=stat.S_IFBLK)
             elif tarinfo.ischr():
diff --git a/src/borg/fuse.py b/src/borg/fuse.py
index e2ef8eaa9..b81f37f1f 100644
--- a/src/borg/fuse.py
+++ b/src/borg/fuse.py
@@ -35,7 +35,8 @@ from .crypto.low_level import blake2b_128
 from .archiver import Archiver
 from .archive import Archive, get_item_uid_gid
 from .hashindex import FuseVersionsIndex
-from .helpers import daemonize, daemonizing, hardlinkable, signal_handler, format_file_size, Error
+from .helpers import daemonize, daemonizing, signal_handler, format_file_size, Error
+from .helpers import HardLinkManager
 from .helpers import msgpack
 from .item import Item
 from .lrucache import LRUCache
@@ -339,15 +340,9 @@ class FuseBackend:
                           consider_part_files=self._args.consider_part_files)
         strip_components = self._args.strip_components
         matcher = Archiver.build_matcher(self._args.patterns, self._args.paths)
-        partial_extract = not matcher.empty() or strip_components
-        hardlink_masters = {} if partial_extract else None
+        hlm = HardLinkManager(id_type=bytes, info_type=str)  # hlid -> path
 
-        def peek_and_store_hardlink_masters(item, matched):
-            if (partial_extract and not matched and hardlinkable(item.mode) and
-                    item.get('hardlink_master', True) and 'source' not in item):
-                hardlink_masters[item.get('path')] = (item.get('chunks'), None)
-
-        filter = Archiver.build_filter(matcher, peek_and_store_hardlink_masters, strip_components)
+        filter = Archiver.build_filter(matcher, strip_components)
         for item_inode, item in self.cache.iter_archive_items(archive.metadata.items, filter=filter,
                                                               consider_part_files=self._args.consider_part_files):
             if strip_components:
@@ -369,15 +364,13 @@ class FuseBackend:
             parent = 1
             for segment in segments[:-1]:
                 parent = self._process_inner(segment, parent)
-            self._process_leaf(segments[-1], item, parent, prefix, is_dir, item_inode,
-                               hardlink_masters, strip_components)
+            self._process_leaf(segments[-1], item, parent, prefix, is_dir, item_inode, hlm)
         duration = time.perf_counter() - t0
         logger.debug('fuse: _process_archive completed in %.1f s for archive %s', duration, archive.name)
 
-    def _process_leaf(self, name, item, parent, prefix, is_dir, item_inode, hardlink_masters, stripped_components):
+    def _process_leaf(self, name, item, parent, prefix, is_dir, item_inode, hlm):
         path = item.path
         del item.path  # save some space
-        hardlink_masters = hardlink_masters or {}
 
         def file_version(item, path):
             if 'chunks' in item:
@@ -402,10 +395,9 @@ class FuseBackend:
             version_enc = os.fsencode('.%05d' % version)
             return name + version_enc + ext
 
-        if 'source' in item and hardlinkable(item.mode):
-            source = os.sep.join(item.source.split(os.sep)[stripped_components:])
-            chunks, link_target = hardlink_masters.get(item.source, (None, source))
-            if link_target:
+        if 'hlid' in item:
+            link_target = hlm.retrieve(id=item.hlid, default=None)
+            if link_target is not None:
                 # Hard link was extracted previously, just link
                 link_target = os.fsencode(link_target)
                 if self.versions:
@@ -415,19 +407,16 @@ class FuseBackend:
                 try:
                     inode = self.find_inode(link_target, prefix)
                 except KeyError:
-                    logger.warning('Skipping broken hard link: %s -> %s', path, source)
+                    logger.warning('Skipping broken hard link: %s -> %s', path, link_target)
                     return
                 item = self.get_item(inode)
                 item.nlink = item.get('nlink', 1) + 1
                 self._items[inode] = item
-            elif chunks is not None:
-                # assign chunks to this item, since the item which had the chunks was not extracted
-                item.chunks = chunks
+            else:
                 inode = item_inode
                 self._items[inode] = item
-                if hardlink_masters:
-                    # Update master entry with extracted item path, so that following hardlinks don't extract twice.
-                    hardlink_masters[item.source] = (None, path)
+                # remember extracted item path, so that following hardlinks don't extract twice.
+                hlm.remember(id=item.hlid, info=path)
         else:
             inode = item_inode
 
@@ -436,7 +425,7 @@ class FuseBackend:
             enc_path = os.fsencode(path)
             version = file_version(item, enc_path)
             if version is not None:
-                # regular file, with contents - maybe a hardlink master
+                # regular file, with contents
                 name = make_versioned_name(name, version)
                 self.file_versions[enc_path] = version
 
diff --git a/src/borg/helpers/fs.py b/src/borg/helpers/fs.py
index d1a412da0..89b54a09d 100644
--- a/src/borg/helpers/fs.py
+++ b/src/borg/helpers/fs.py
@@ -1,4 +1,5 @@
 import errno
+import hashlib
 import os
 import os.path
 import re
@@ -165,9 +166,70 @@ def make_path_safe(path):
     return _safe_re.sub('', path) or '.'
 
 
-def hardlinkable(mode):
-    """return True if we support hardlinked items of this type"""
-    return stat.S_ISREG(mode) or stat.S_ISBLK(mode) or stat.S_ISCHR(mode) or stat.S_ISFIFO(mode)
+class HardLinkManager:
+    """
+    Manage hardlinks (and avoid code duplication doing so).
+
+    A) When creating a borg2 archive from the filesystem, we have to maintain a mapping like:
+       (dev, ino) -> (hlid, chunks)  # for fs_hl_targets
+       If we encounter the same (dev, ino) again later, we'll just re-use the hlid and chunks list.
+
+    B) When extracting a borg2 archive to the filesystem, we have to maintain a mapping like:
+       hlid -> path
+       If we encounter the same hlid again later, we hardlink to the path of the already extracted content of same hlid.
+
+    C) When transferring from a borg1 archive, we need:
+       path -> chunks, chunks_healthy  # for borg1_hl_targets
+       If we encounter a regular file item with source == path later, we reuse chunks and chunks_healthy
+       and create the same hlid = hardlink_id(source).
+
+    D) When importing a tar file (simplified 1-pass way for now, not creating borg hardlink items):
+       path -> chunks
+       If we encounter a LNK tar entry later with linkname==path, we re-use the chunks and create a regular file item.
+       For better hardlink support (including the very first hardlink item for each group of same-target hardlinks),
+       we would need a 2-pass processing, which is not yet implemented.
+    """
+    def __init__(self, *, id_type, info_type):
+        self._map = {}
+        self.id_type = id_type
+        self.info_type = info_type
+
+    def borg1_hardlinkable(self, mode):  # legacy
+        return stat.S_ISREG(mode) or stat.S_ISBLK(mode) or stat.S_ISCHR(mode) or stat.S_ISFIFO(mode)
+
+    def borg1_hardlink_master(self, item):  # legacy
+        return item.get('hardlink_master', True) and 'source' not in item and self.borg1_hardlinkable(item.mode)
+
+    def borg1_hardlink_slave(self, item):  # legacy
+        return 'source' in item and self.borg1_hardlinkable(item.mode)
+
+    def hardlink_id(self, path):
+        """compute a hardlink id from a path"""
+        assert isinstance(path, bytes)
+        return hashlib.sha256(path).digest()
+
+    def remember(self, *, id, info):
+        """
+        remember stuff from a (usually contentful) item.
+
+        :param id: some id used to reference to the contentful item, could be:
+                   a path (tar style, old borg style) [bytes]
+                   a hlid (new borg style) [bytes]
+                   a (dev, inode) tuple (filesystem)
+        :param info: information to remember, could be:
+                     chunks / chunks_healthy list
+                     hlid
+        """
+        assert isinstance(id, self.id_type)
+        assert isinstance(info, self.info_type)
+        self._map[id] = info
+
+    def retrieve(self, id, *, default=None):
+        """
+        retrieve stuff to use it in a (usually contentless) item.
+        """
+        assert isinstance(id, self.id_type)
+        return self._map.get(id, default)
 
 
 def scandir_keyfunc(dirent):
diff --git a/src/borg/helpers/parseformat.py b/src/borg/helpers/parseformat.py
index 9bcbce22c..414402de0 100644
--- a/src/borg/helpers/parseformat.py
+++ b/src/borg/helpers/parseformat.py
@@ -695,7 +695,8 @@ class ItemFormatter(BaseFormatter):
     KEY_DESCRIPTIONS = {
         'bpath': 'verbatim POSIX path, can contain any character except NUL',
         'path': 'path interpreted as text (might be missing non-text characters, see bpath)',
-        'source': 'link target for links (identical to linktarget)',
+        'source': 'link target for symlinks (identical to linktarget)',
+        'hlid': 'hard link identity (same if hardlinking same fs object)',
         'extra': 'prepends {source} with " -> " for soft links and " link to " for hard links',
         'csize': 'compressed size',
         'dsize': 'deduplicated size',
@@ -706,7 +707,7 @@ class ItemFormatter(BaseFormatter):
         'health': 'either "healthy" (file ok) or "broken" (if file has all-zero replacement chunks)',
     }
     KEY_GROUPS = (
-        ('type', 'mode', 'uid', 'gid', 'user', 'group', 'path', 'bpath', 'source', 'linktarget', 'flags'),
+        ('type', 'mode', 'uid', 'gid', 'user', 'group', 'path', 'bpath', 'source', 'linktarget', 'hlid', 'flags'),
         ('size', 'csize', 'dsize', 'dcsize', 'num_chunks', 'unique_chunks'),
         ('mtime', 'ctime', 'atime', 'isomtime', 'isoctime', 'isoatime'),
         tuple(sorted(hash_algorithms)),
@@ -802,11 +803,9 @@ class ItemFormatter(BaseFormatter):
         extra = ''
         if source:
             source = remove_surrogates(source)
-            if item_type == 'l':
-                extra = ' -> %s' % source
-            else:
-                mode = 'h' + mode[1:]
-                extra = ' link to %s' % source
+            extra = ' -> %s' % source
+        hlid = item.get('hlid')
+        hlid = bin_to_hex(hlid) if hlid else ''
         item_data['type'] = item_type
         item_data['mode'] = mode
         item_data['user'] = item.user or item.uid
@@ -822,6 +821,7 @@ class ItemFormatter(BaseFormatter):
             item_data['health'] = 'broken' if 'chunks_healthy' in item else 'healthy'
         item_data['source'] = source
         item_data['linktarget'] = source
+        item_data['hlid'] = hlid
         item_data['flags'] = item.get('bsdflags')
         for key in self.used_call_keys:
             item_data[key] = self.call_keys[key](item)
diff --git a/src/borg/item.pyx b/src/borg/item.pyx
index 764279db0..9ea76f2de 100644
--- a/src/borg/item.pyx
+++ b/src/borg/item.pyx
@@ -214,7 +214,6 @@ class Item(PropDict):
         except AttributeError:
             if stat.S_ISLNK(self.mode):
                 # get out of here quickly. symlinks have no own chunks, their fs size is the length of the target name.
-                # also, there is the dual-use issue of .source (#2343), so don't confuse it with a hardlink slave.
                 return len(self.source)
             # no precomputed (c)size value available, compute it:
             try:
diff --git a/src/borg/testsuite/archiver.py b/src/borg/testsuite/archiver.py
index b69fe819f..402239455 100644
--- a/src/borg/testsuite/archiver.py
+++ b/src/borg/testsuite/archiver.py
@@ -321,7 +321,7 @@ class ArchiverTestCaseBase(BaseTestCase):
                 contents = b'X' * size
             fd.write(contents)
 
-    def create_test_files(self):
+    def create_test_files(self, create_hardlinks=True):
         """Create a minimal test case including all supported file types
         """
         # File
@@ -332,7 +332,7 @@ class ArchiverTestCaseBase(BaseTestCase):
         # File mode
         os.chmod('input/file1', 0o4755)
         # Hard link
-        if are_hardlinks_supported():
+        if are_hardlinks_supported() and create_hardlinks:
             os.link(os.path.join(self.input_path, 'file1'),
                     os.path.join(self.input_path, 'hardlink'))
         # Symlink
@@ -432,7 +432,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
             self.assert_in(name, list_output)
         self.assert_dirs_equal('input', 'output/input')
         info_output = self.cmd('info', self.repository_location + '::test')
-        item_count = 4 if has_lchflags else 5  # one file is UF_NODUMP
+        item_count = 5 if has_lchflags else 6  # one file is UF_NODUMP
         self.assert_in('Number of files: %d' % item_count, info_output)
         shutil.rmtree(self.cache_path)
         info_output2 = self.cmd('info', self.repository_location + '::test')
@@ -506,6 +506,29 @@ class ArchiverTestCase(ArchiverTestCaseBase):
             self.cmd('extract', self.repository_location + '::test')
             assert os.readlink('input/link1') == 'somewhere'
 
+    @pytest.mark.skipif(not are_symlinks_supported() or not are_hardlinks_supported(),
+                        reason='symlinks or hardlinks not supported')
+    def test_hardlinked_symlinks_extract(self):
+        self.create_regular_file('target', size=1024)
+        with changedir('input'):
+            os.symlink('target', 'symlink1')
+            os.link('symlink1', 'symlink2', follow_symlinks=False)
+        self.cmd('init', '--encryption=repokey', self.repository_location)
+        self.cmd('create', self.repository_location + '::test', 'input')
+        with changedir('output'):
+            output = self.cmd('extract', self.repository_location + '::test')
+            print(output)
+            with changedir('input'):
+                assert os.path.exists('target')
+                assert os.readlink('symlink1') == 'target'
+                assert os.readlink('symlink2') == 'target'
+                st1 = os.stat('symlink1', follow_symlinks=False)
+                st2 = os.stat('symlink2', follow_symlinks=False)
+                assert st1.st_nlink == 2
+                assert st2.st_nlink == 2
+                assert st1.st_ino == st2.st_ino
+                assert st1.st_size == st2.st_size
+
     @pytest.mark.skipif(not is_utime_fully_supported(), reason='cannot properly setup and execute test without utime')
     def test_atime(self):
         def has_noatime(some_file):
@@ -2661,7 +2684,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
                 hl3 = os.path.join(mountpoint, 'input', 'hardlink3', 'hardlink3.00001')
                 assert os.stat(hl1).st_ino == os.stat(hl2).st_ino == os.stat(hl3).st_ino
                 assert open(hl3, 'rb').read() == b'123456'
-        # similar again, but exclude the hardlink master:
+        # similar again, but exclude the 1st hardlink:
         with self.fuse_mount(self.repository_location, mountpoint, '-o', 'versions', '-e', 'input/hardlink1'):
             if are_hardlinks_supported():
                 hl2 = os.path.join(mountpoint, 'input', 'hardlink2', 'hardlink2.00001')
@@ -3475,7 +3498,7 @@ id: 2 / e29442 3506da 4e1ea7 / 25f62a 5a3d41 - 02
             assert os.stat('input/dir1/source2').st_nlink == 2
 
     def test_import_tar(self, tar_format='PAX'):
-        self.create_test_files()
+        self.create_test_files(create_hardlinks=False)  # hardlinks become separate files
         os.unlink('input/flagfile')
         self.cmd('init', '--encryption=none', self.repository_location)
         self.cmd('create', self.repository_location + '::src', 'input')
@@ -3489,7 +3512,7 @@ id: 2 / e29442 3506da 4e1ea7 / 25f62a 5a3d41 - 02
     def test_import_tar_gz(self, tar_format='GNU'):
         if not shutil.which('gzip'):
             pytest.skip('gzip is not installed')
-        self.create_test_files()
+        self.create_test_files(create_hardlinks=False)  # hardlinks become separate files
         os.unlink('input/flagfile')
         self.cmd('init', '--encryption=none', self.repository_location)
         self.cmd('create', self.repository_location + '::src', 'input')
@@ -4444,26 +4467,23 @@ def test_chunk_content_equal():
 
 
 class TestBuildFilter:
-    @staticmethod
-    def peek_and_store_hardlink_masters(item, matched):
-        pass
 
     def test_basic(self):
         matcher = PatternMatcher()
         matcher.add([parse_pattern('included')], IECommand.Include)
-        filter = Archiver.build_filter(matcher, self.peek_and_store_hardlink_masters, 0)
+        filter = Archiver.build_filter(matcher, 0)
         assert filter(Item(path='included'))
         assert filter(Item(path='included/file'))
         assert not filter(Item(path='something else'))
 
     def test_empty(self):
         matcher = PatternMatcher(fallback=True)
-        filter = Archiver.build_filter(matcher, self.peek_and_store_hardlink_masters, 0)
+        filter = Archiver.build_filter(matcher, 0)
         assert filter(Item(path='anything'))
 
     def test_strip_components(self):
         matcher = PatternMatcher(fallback=True)
-        filter = Archiver.build_filter(matcher, self.peek_and_store_hardlink_masters, strip_components=1)
+        filter = Archiver.build_filter(matcher, strip_components=1)
         assert not filter(Item(path='shallow'))
         assert not filter(Item(path='shallow/'))  # can this even happen? paths are normalized...
         assert filter(Item(path='deep enough/file'))

From e5f1a4fb4d74cc5cdc1cd38f14200f4db782a35a Mon Sep 17 00:00:00 2001
From: Thomas Waldmann <tw@waldmann-edv.de>
Date: Wed, 11 May 2022 23:52:04 +0200
Subject: [PATCH 008/160] recreate: cachedir_masters not needed any more

now all hardlinked regular file items have chunks.
---
 src/borg/archive.py | 19 +------------------
 1 file changed, 1 insertion(+), 18 deletions(-)

diff --git a/src/borg/archive.py b/src/borg/archive.py
index da083eac6..ed17465ea 100644
--- a/src/borg/archive.py
+++ b/src/borg/archive.py
@@ -2199,30 +2199,13 @@ class ArchiveRecreater:
         tag_files = []
         tagged_dirs = []
 
-        # to support reading hard-linked CACHEDIR.TAGs (aka CACHE_TAG_NAME):
-        cachedir_masters = {}
-
-        if self.exclude_caches:
-            # sadly, due to how CACHEDIR.TAG works (filename AND file [header] contents) and
-            # how borg deals with hardlinks (slave hardlinks referring back to master hardlinks),
-            # we need to pass over the archive collecting hardlink master paths.
-            # as seen in issue #4911, the master paths can have an arbitrary filenames,
-            # not just CACHEDIR.TAG.
-            for item in archive.iter_items(filter=lambda item: os.path.basename(item.path) == CACHE_TAG_NAME):
-                if stat.S_ISREG(item.mode) and 'chunks' not in item and 'source' in item:
-                    # this is a hardlink slave, referring back to its hardlink master (via item.source)
-                    cachedir_masters[item.source] = None  # we know the key (path), but not the value (item) yet
-
         for item in archive.iter_items(
                 filter=lambda item: os.path.basename(item.path) == CACHE_TAG_NAME or matcher.match(item.path)):
-            if self.exclude_caches and item.path in cachedir_masters:
-                cachedir_masters[item.path] = item
             dir, tag_file = os.path.split(item.path)
             if tag_file in self.exclude_if_present:
                 exclude(dir, item)
             elif self.exclude_caches and tag_file == CACHE_TAG_NAME and stat.S_ISREG(item.mode):
-                content_item = item if 'chunks' in item else cachedir_masters[item.source]
-                file = open_item(archive, content_item)
+                file = open_item(archive, item)
                 if file.read(len(CACHE_TAG_CONTENTS)) == CACHE_TAG_CONTENTS:
                     exclude(dir, item)
         matcher.add(tag_files, IECommand.Include)

From d3dfa3be30a01012f1948a086e84d6d36cd33f49 Mon Sep 17 00:00:00 2001
From: Thomas Waldmann <tw@waldmann-edv.de>
Date: Tue, 17 May 2022 02:00:00 +0200
Subject: [PATCH 009/160] use version 2 for new archives

but still be able to read v1 archives
for borg transfer.
---
 src/borg/archive.py            | 8 ++++----
 src/borg/cache.py              | 2 +-
 src/borg/testsuite/archiver.py | 2 +-
 3 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/src/borg/archive.py b/src/borg/archive.py
index ed17465ea..ba19e72bb 100644
--- a/src/borg/archive.py
+++ b/src/borg/archive.py
@@ -472,7 +472,7 @@ class Archive:
     def _load_meta(self, id):
         data = self.key.decrypt(id, self.repository.get(id))
         metadata = ArchiveItem(internal_dict=msgpack.unpackb(data))
-        if metadata.version != 1:
+        if metadata.version not in (1, 2):  # legacy: still need to read v1 archives
             raise Exception('Unknown archive metadata version')
         return metadata
 
@@ -601,7 +601,7 @@ Utilization of max. archive size: {csize_max:.0%}
         self.start = start
         self.end = end
         metadata = {
-            'version': 1,
+            'version': 2,
             'name': name,
             'comment': comment or '',
             'items': self.items_buffer.chunks,
@@ -1748,7 +1748,7 @@ class ArchiveChecker:
                 continue
             if not valid_msgpacked_dict(data, archive_keys_serialized):
                 continue
-            if b'cmdline' not in data or b'\xa7version\x01' not in data:
+            if b'cmdline' not in data or b'\xa7version\x02' not in data:
                 continue
             try:
                 archive = msgpack.unpackb(data)
@@ -1989,7 +1989,7 @@ class ArchiveChecker:
                     del self.manifest.archives[info.name]
                     continue
                 archive = ArchiveItem(internal_dict=msgpack.unpackb(data))
-                if archive.version != 1:
+                if archive.version != 2:
                     raise Exception('Unknown archive metadata version')
                 archive.cmdline = [safe_decode(arg) for arg in archive.cmdline]
                 items_buffer = ChunkBuffer(self.key)
diff --git a/src/borg/cache.py b/src/borg/cache.py
index 6cd612359..58ceb541b 100644
--- a/src/borg/cache.py
+++ b/src/borg/cache.py
@@ -757,7 +757,7 @@ class LocalCache(CacheStatsMixin):
             csize, data = decrypted_repository.get(archive_id)
             chunk_idx.add(archive_id, 1, len(data), csize)
             archive = ArchiveItem(internal_dict=msgpack.unpackb(data))
-            if archive.version != 1:
+            if archive.version not in (1, 2):  # legacy
                 raise Exception('Unknown archive metadata version')
             sync = CacheSynchronizer(chunk_idx)
             for item_id, (csize, data) in zip(archive.items, decrypted_repository.get_many(archive.items)):
diff --git a/src/borg/testsuite/archiver.py b/src/borg/testsuite/archiver.py
index 402239455..32feeb44e 100644
--- a/src/borg/testsuite/archiver.py
+++ b/src/borg/testsuite/archiver.py
@@ -3873,7 +3873,7 @@ class ArchiverCheckTestCase(ArchiverTestCaseBase):
                 'username': 'bar',
                 'name': 'archive1',
                 'time': '2016-12-15T18:49:51.849711',
-                'version': 1,
+                'version': 2,
             })
             archive_id = key.id_hash(archive)
             repository.put(archive_id, key.encrypt(archive_id, archive))

From 8798b0340a63af9829e7d223755c58b2d04a4363 Mon Sep 17 00:00:00 2001
From: Thomas Waldmann <tw@waldmann-edv.de>
Date: Tue, 17 May 2022 17:21:19 +0200
Subject: [PATCH 010/160] use whitelist approach to make sure item._dict is
 clean

---
 src/borg/archiver.py | 17 +++++++++++++----
 1 file changed, 13 insertions(+), 4 deletions(-)

diff --git a/src/borg/archiver.py b/src/borg/archiver.py
index 4b6fd1782..23ab03d93 100644
--- a/src/borg/archiver.py
+++ b/src/borg/archiver.py
@@ -345,6 +345,11 @@ class Archiver:
                other_repository=None, other_manifest=None, other_key=None):
         """archives transfer from other repository"""
 
+        ITEM_KEY_WHITELIST = {'path', 'source', 'rdev', 'chunks', 'chunks_healthy', 'hlid',
+                              'mode', 'user', 'group', 'uid', 'gid', 'mtime', 'atime', 'ctime', 'birthtime', 'size',
+                              'xattrs', 'bsdflags', 'acl_nfs4', 'acl_access', 'acl_default', 'acl_extended',
+                              'part'}
+
         def upgrade_item(item):
             """upgrade item as needed, get rid of legacy crap"""
             if hlm.borg1_hardlink_master(item):
@@ -364,10 +369,14 @@ class Archiver:
                 if attr in item:
                     ns = getattr(item, attr)  # decode (bigint or Timestamp) --> int ns
                     setattr(item, attr, ns)  # encode int ns --> msgpack.Timestamp only, no bigint any more
-            item._dict.pop('hardlink_master', None)  # not used for hardlinks any more, replaced by hlid
-            item._dict.pop('acl', None)  # remove remnants of bug in attic <= 0.13
-            item.get_size(memorize=True)  # if not already present: compute+remember size for items with chunks
-            return item
+            # make sure we only have desired stuff in the new item. specifically, make sure to get rid of:
+            # - 'acl' remnants of bug in attic <= 0.13
+            # - 'hardlink_master' (superseded by hlid)
+            new_item_dict = {key: value for key, value in item.as_dict().items() if key in ITEM_KEY_WHITELIST}
+            new_item = Item(internal_dict=new_item_dict)
+            new_item.get_size(memorize=True)  # if not already present: compute+remember size for items with chunks
+            assert all(key in new_item for key in REQUIRED_ITEM_KEYS)
+            return new_item
 
         def upgrade_compressed_chunk(chunk):
             if ZLIB_legacy.detect(chunk):

From 32a3601e4a10ac381eaa6c7a6e665c676ae036b9 Mon Sep 17 00:00:00 2001
From: Thomas Waldmann <tw@waldmann-edv.de>
Date: Tue, 17 May 2022 19:46:52 +0200
Subject: [PATCH 011/160] compute hlid from inode / device

---
 src/borg/archive.py    | 14 +++++++-------
 src/borg/archiver.py   |  4 ++--
 src/borg/helpers/fs.py | 14 ++++++++++----
 3 files changed, 19 insertions(+), 13 deletions(-)

diff --git a/src/borg/archive.py b/src/borg/archive.py
index ba19e72bb..15cfc5d55 100644
--- a/src/borg/archive.py
+++ b/src/borg/archive.py
@@ -1236,7 +1236,7 @@ class FilesystemObjectProcessors:
         self.show_progress = show_progress
         self.print_file_status = file_status_printer or (lambda *args: None)
 
-        self.hlm = HardLinkManager(id_type=tuple, info_type=tuple)  # (dev, ino) -> (hlid, chunks)
+        self.hlm = HardLinkManager(id_type=tuple, info_type=(list, type(None)))  # (dev, ino) -> chunks or None
         self.stats = Statistics(output_json=log_json, iec=iec)  # threading: done by cache (including progress)
         self.cwd = os.getcwd()
         self.chunker = get_chunker(*chunker_params, seed=key.chunk_seed, sparse=sparse)
@@ -1249,20 +1249,20 @@ class FilesystemObjectProcessors:
         update_map = False
         if hardlinked:
             status = 'h'  # hardlink
-            hlid, chunks = self.hlm.retrieve(id=(st.st_ino, st.st_dev), default=(None, None))
-            if hlid is None:
+            nothing = object()
+            chunks = self.hlm.retrieve(id=(st.st_ino, st.st_dev), default=nothing)
+            if chunks is nothing:
                 update_map = True
-                hlid = self.hlm.hardlink_id(item._dict['path'])
-            item.hlid = hlid
-            if chunks is not None:
+            elif chunks is not None:
                 item.chunks = chunks
+            item.hlid = self.hlm.hardlink_id_from_inode(ino=st.st_ino, dev=st.st_dev)
         yield item, status, hardlinked
         self.add_item(item, stats=self.stats)
         if update_map:
             # remember the hlid of this fs object and if the item has chunks,
             # also remember them, so we do not have to re-chunk a hardlink.
             chunks = item.chunks if 'chunks' in item else None
-            self.hlm.remember(id=(st.st_ino, st.st_dev), info=(hlid, chunks))
+            self.hlm.remember(id=(st.st_ino, st.st_dev), info=chunks)
 
     def process_dir_with_fd(self, *, path, fd, st):
         with self.create_helper(path, st, 'd', hardlinkable=False) as (item, status, hardlinked):
diff --git a/src/borg/archiver.py b/src/borg/archiver.py
index 23ab03d93..7e0f67f48 100644
--- a/src/borg/archiver.py
+++ b/src/borg/archiver.py
@@ -353,10 +353,10 @@ class Archiver:
         def upgrade_item(item):
             """upgrade item as needed, get rid of legacy crap"""
             if hlm.borg1_hardlink_master(item):
-                item._dict['hlid'] = hlid = hlm.hardlink_id(item._dict['path'])
+                item._dict['hlid'] = hlid = hlm.hardlink_id_from_path(item._dict['path'])
                 hlm.remember(id=hlid, info=(item._dict.get('chunks'), item._dict.get('chunks_healthy')))
             elif hlm.borg1_hardlink_slave(item):
-                item._dict['hlid'] = hlid = hlm.hardlink_id(item._dict['source'])
+                item._dict['hlid'] = hlid = hlm.hardlink_id_from_path(item._dict['source'])
                 chunks, chunks_healthy = hlm.retrieve(id=hlid, default=(None, None))
                 if chunks is not None:
                     item._dict['chunks'] = chunks
diff --git a/src/borg/helpers/fs.py b/src/borg/helpers/fs.py
index 89b54a09d..fecda9c69 100644
--- a/src/borg/helpers/fs.py
+++ b/src/borg/helpers/fs.py
@@ -181,7 +181,7 @@ class HardLinkManager:
     C) When transferring from a borg1 archive, we need:
        path -> chunks, chunks_healthy  # for borg1_hl_targets
        If we encounter a regular file item with source == path later, we reuse chunks and chunks_healthy
-       and create the same hlid = hardlink_id(source).
+       and create the same hlid = hardlink_id_from_path(source).
 
     D) When importing a tar file (simplified 1-pass way for now, not creating borg hardlink items):
        path -> chunks
@@ -203,11 +203,17 @@ class HardLinkManager:
     def borg1_hardlink_slave(self, item):  # legacy
         return 'source' in item and self.borg1_hardlinkable(item.mode)
 
-    def hardlink_id(self, path):
+    def hardlink_id_from_path(self, path):
         """compute a hardlink id from a path"""
         assert isinstance(path, bytes)
         return hashlib.sha256(path).digest()
 
+    def hardlink_id_from_inode(self, *, ino, dev):
+        """compute a hardlink id from an inode"""
+        assert isinstance(ino, int)
+        assert isinstance(dev, int)
+        return hashlib.sha256(f'{ino}/{dev}'.encode()).digest()
+
     def remember(self, *, id, info):
         """
         remember stuff from a (usually contentful) item.
@@ -220,8 +226,8 @@ class HardLinkManager:
                      chunks / chunks_healthy list
                      hlid
         """
-        assert isinstance(id, self.id_type)
-        assert isinstance(info, self.info_type)
+        assert isinstance(id, self.id_type), f"key is {key!r}, not of type {self.key_type}"
+        assert isinstance(info, self.info_type), f"info is {info!r}, not of type {self.info_type}"
         self._map[id] = info
 
     def retrieve(self, id, *, default=None):

From 6584a92c8108194adfd4ab8ab63ab0a9f5e87cc6 Mon Sep 17 00:00:00 2001
From: Thomas Waldmann <tw@waldmann-edv.de>
Date: Tue, 17 May 2022 22:54:12 +0200
Subject: [PATCH 012/160] compression: use the 2 bytes for type and level,
 fixes #6698

adapt borg transfer, transferred chunks are set to compression level "unknown".
---
 src/borg/archiver.py      |  7 ++++-
 src/borg/compress.pyx     | 56 ++++++++++++++++++++++-----------------
 src/borg/testsuite/key.py |  8 +++---
 3 files changed, 42 insertions(+), 29 deletions(-)

diff --git a/src/borg/archiver.py b/src/borg/archiver.py
index 7e0f67f48..7408931ca 100644
--- a/src/borg/archiver.py
+++ b/src/borg/archiver.py
@@ -379,8 +379,13 @@ class Archiver:
             return new_item
 
         def upgrade_compressed_chunk(chunk):
+            level = b'\xFF'  # FF means unknown compression level
             if ZLIB_legacy.detect(chunk):
-                chunk = ZLIB.ID + chunk  # get rid of the attic legacy: prepend separate type bytes for zlib
+                ctype = ZLIB.ID
+                chunk = ctype + level + chunk  # get rid of the attic legacy: prepend separate type/level bytes
+            else:
+                ctype = chunk[0:1]
+                chunk = ctype + level + chunk[2:]  # keep type same, but set level
             return chunk
 
         dry_run = args.dry_run
diff --git a/src/borg/compress.pyx b/src/borg/compress.pyx
index 7997456c6..70c95df70 100644
--- a/src/borg/compress.pyx
+++ b/src/borg/compress.pyx
@@ -56,16 +56,21 @@ cdef class CompressorBase:
     also handles compression format auto detection and
     adding/stripping the ID header (which enable auto detection).
     """
-    ID = b'\xFF\xFF'  # reserved and not used
-                      # overwrite with a unique 2-bytes bytestring in child classes
+    ID = b'\xFF'  # reserved and not used
+                  # overwrite with a unique 1-byte bytestring in child classes
     name = 'baseclass'
 
     @classmethod
     def detect(cls, data):
         return data.startswith(cls.ID)
 
-    def __init__(self, **kwargs):
-        pass
+    def __init__(self, level=255, **kwargs):
+        assert 0 <= level <= 255
+        if self.ID is not None:
+            self.id_level = self.ID + bytes((level, ))  # level 255 means "unknown level"
+            assert len(self.id_level) == 2
+        else:
+            self.id_level = None
 
     def decide(self, data):
         """
@@ -85,8 +90,8 @@ cdef class CompressorBase:
         Compress *data* (bytes) and return bytes result. Prepend the ID bytes of this compressor,
         which is needed so that the correct decompressor can be used for decompression.
         """
-        # add ID bytes
-        return self.ID + data
+        # add id_level bytes
+        return self.id_level + data
 
     def decompress(self, data):
         """
@@ -96,7 +101,7 @@ cdef class CompressorBase:
         Only handles input generated by _this_ Compressor - for a general purpose
         decompression method see *Compressor.decompress*.
         """
-        # strip ID bytes
+        # strip id_level bytes
         return data[2:]
 
 cdef class DecidingCompressor(CompressorBase):
@@ -106,8 +111,8 @@ cdef class DecidingCompressor(CompressorBase):
     """
     name = 'decidebaseclass'
 
-    def __init__(self, **kwargs):
-        super().__init__(**kwargs)
+    def __init__(self, level=255, **kwargs):
+        super().__init__(level=level, **kwargs)
 
     def _decide(self, data):
         """
@@ -148,9 +153,12 @@ class CNONE(CompressorBase):
     """
     none - no compression, just pass through data
     """
-    ID = b'\x00\x00'
+    ID = b'\x00'
     name = 'none'
 
+    def __init__(self, level=255, **kwargs):
+        super().__init__(level=level, **kwargs)  # no defined levels for CNONE, so just say "unknown"
+
     def compress(self, data):
         return super().compress(data)
 
@@ -170,11 +178,11 @@ class LZ4(DecidingCompressor):
         - wrapper releases CPython's GIL to support multithreaded code
         - uses safe lz4 methods that never go beyond the end of the output buffer
     """
-    ID = b'\x01\x00'
+    ID = b'\x01'
     name = 'lz4'
 
-    def __init__(self, **kwargs):
-        pass
+    def __init__(self, level=255, **kwargs):
+        super().__init__(level=level, **kwargs)  # no defined levels for LZ4, so just say "unknown"
 
     def _decide(self, idata):
         """
@@ -235,11 +243,11 @@ class LZMA(DecidingCompressor):
     """
     lzma compression / decompression
     """
-    ID = b'\x02\x00'
+    ID = b'\x02'
     name = 'lzma'
 
     def __init__(self, level=6, **kwargs):
-        super().__init__(**kwargs)
+        super().__init__(level=level, **kwargs)
         self.level = level
         if lzma is None:
             raise ValueError('No lzma support found.')
@@ -270,11 +278,11 @@ class ZSTD(DecidingCompressor):
     # This is a NOT THREAD SAFE implementation.
     # Only ONE python context must be created at a time.
     # It should work flawlessly as long as borg will call ONLY ONE compression job at time.
-    ID = b'\x03\x00'
+    ID = b'\x03'
     name = 'zstd'
 
     def __init__(self, level=3, **kwargs):
-        super().__init__(**kwargs)
+        super().__init__(level=level, **kwargs)
         self.level = level
 
     def _decide(self, idata):
@@ -335,11 +343,11 @@ class ZLIB(DecidingCompressor):
     """
     zlib compression / decompression (python stdlib)
     """
-    ID = b'\x05\x00'
+    ID = b'\x05'
     name = 'zlib'
 
     def __init__(self, level=6, **kwargs):
-        super().__init__(**kwargs)
+        super().__init__(level=level, **kwargs)
         self.level = level
 
     def _decide(self, data):
@@ -373,8 +381,8 @@ class ZLIB_legacy(CompressorBase):
           Newer borg uses the ZLIB class that has separate ID bytes (as all the other
           compressors) and does not need this hack.
     """
-    ID = b'\x08\x00'  # not used here, see detect()
-    # avoid all 0x.8.. IDs elsewhere!
+    ID = b'\x08'  # not used here, see detect()
+    # avoid all 0x.8 IDs elsewhere!
     name = 'zlib_legacy'
 
     @classmethod
@@ -386,7 +394,7 @@ class ZLIB_legacy(CompressorBase):
         return check_ok and is_deflate
 
     def __init__(self, level=6, **kwargs):
-        super().__init__(**kwargs)
+        super().__init__(level=level, **kwargs)
         self.level = level
 
     def compress(self, data):
@@ -478,14 +486,14 @@ class ObfuscateSize(CompressorBase):
     """
     Meta-Compressor that obfuscates the compressed data size.
     """
-    ID = b'\x04\x00'
+    ID = b'\x04'
     name = 'obfuscate'
 
     header_fmt = Struct('>I')
     header_len = len(header_fmt.pack(0))
 
     def __init__(self, level=None, compressor=None):
-        super().__init__()
+        super().__init__(level=level)  # data will be encrypted, so we can tell the level
         self.compressor = compressor
         if level is None:
             pass  # decompression
diff --git a/src/borg/testsuite/key.py b/src/borg/testsuite/key.py
index e0be752fa..5073c5b23 100644
--- a/src/borg/testsuite/key.py
+++ b/src/borg/testsuite/key.py
@@ -256,8 +256,8 @@ class TestKey:
         plaintext = b'123456789'
         id = key.id_hash(plaintext)
         authenticated = key.encrypt(id, plaintext)
-        # 0x07 is the key TYPE, \x0000 identifies no compression.
-        assert authenticated == b'\x07\x00\x00' + plaintext
+        # 0x07 is the key TYPE, \x00ff identifies no compression / unknown level.
+        assert authenticated == b'\x07\x00\xff' + plaintext
 
     def test_blake2_authenticated_encrypt(self, monkeypatch):
         monkeypatch.setenv('BORG_PASSPHRASE', 'test')
@@ -267,8 +267,8 @@ class TestKey:
         plaintext = b'123456789'
         id = key.id_hash(plaintext)
         authenticated = key.encrypt(id, plaintext)
-        # 0x06 is the key TYPE, 0x0000 identifies no compression.
-        assert authenticated == b'\x06\x00\x00' + plaintext
+        # 0x06 is the key TYPE, 0x00ff identifies no compression / unknown level.
+        assert authenticated == b'\x06\x00\xff' + plaintext
 
 
 class TestTAM:

From 72c68c49d09963e3106dca873d76fbd68db32682 Mon Sep 17 00:00:00 2001
From: Thomas Waldmann <tw@waldmann-edv.de>
Date: Tue, 17 May 2022 23:29:58 +0200
Subject: [PATCH 013/160] obfuscation: fix byte order for size, fixes #6701

---
 src/borg/archiver.py  | 12 +++++++++++-
 src/borg/compress.pyx |  2 +-
 2 files changed, 12 insertions(+), 2 deletions(-)

diff --git a/src/borg/archiver.py b/src/borg/archiver.py
index 7408931ca..faf6aa949 100644
--- a/src/borg/archiver.py
+++ b/src/borg/archiver.py
@@ -29,6 +29,7 @@ try:
     from contextlib import contextmanager
     from datetime import datetime, timedelta
     from io import TextIOWrapper
+    from struct import Struct
 
     from .logger import create_logger, setup_logging
 
@@ -44,7 +45,7 @@ try:
     from .archive import has_link
     from .cache import Cache, assert_secure, SecurityManager
     from .constants import *  # NOQA
-    from .compress import CompressionSpec, ZLIB, ZLIB_legacy
+    from .compress import CompressionSpec, ZLIB, ZLIB_legacy, ObfuscateSize
     from .crypto.key import key_creator, key_argument_names, tam_required_file, tam_required
     from .crypto.key import RepoKey, KeyfileKey, Blake2RepoKey, Blake2KeyfileKey, FlexiKey
     from .crypto.keymanager import KeyManager
@@ -386,6 +387,15 @@ class Archiver:
             else:
                 ctype = chunk[0:1]
                 chunk = ctype + level + chunk[2:]  # keep type same, but set level
+            if ctype == ObfuscateSize.ID:
+                # in older borg, we used unusual byte order
+                old_header_fmt = Struct('>I')
+                new_header_fmt = ObfuscateSize.header_fmt
+                length = ObfuscateSize.header_len
+                size_bytes = chunk[2:2+length]
+                size = old_header_fmt.unpack(size_bytes)
+                size_bytes = new_header_fmt.pack(size)
+                chunk = chunk[0:2] + size_bytes + chunk[2+length:]
             return chunk
 
         dry_run = args.dry_run
diff --git a/src/borg/compress.pyx b/src/borg/compress.pyx
index 70c95df70..c63a04df3 100644
--- a/src/borg/compress.pyx
+++ b/src/borg/compress.pyx
@@ -489,7 +489,7 @@ class ObfuscateSize(CompressorBase):
     ID = b'\x04'
     name = 'obfuscate'
 
-    header_fmt = Struct('>I')
+    header_fmt = Struct('<I')
     header_len = len(header_fmt.pack(0))
 
     def __init__(self, level=None, compressor=None):

From c5540c2dd92adf4e3ec67f1741862d817608b27e Mon Sep 17 00:00:00 2001
From: Thomas Waldmann <tw@waldmann-edv.de>
Date: Wed, 18 May 2022 14:47:47 +0200
Subject: [PATCH 014/160] upgrade compressed chunk: fix treatment of
 ObfuscateSize chunks

the inner payload of ObfuscateSize chunks are compressed chunks and need
the same zlib fix and level patching as non-obfuscated compressed chunks.
---
 src/borg/archiver.py | 23 ++++++++++++++++-------
 1 file changed, 16 insertions(+), 7 deletions(-)

diff --git a/src/borg/archiver.py b/src/borg/archiver.py
index faf6aa949..dc0db82f2 100644
--- a/src/borg/archiver.py
+++ b/src/borg/archiver.py
@@ -380,13 +380,18 @@ class Archiver:
             return new_item
 
         def upgrade_compressed_chunk(chunk):
+            def upgrade_zlib_and_level(chunk):
+                if ZLIB_legacy.detect(chunk):
+                    ctype = ZLIB.ID
+                    chunk = ctype + level + chunk  # get rid of the attic legacy: prepend separate type/level bytes
+                else:
+                    ctype = chunk[0:1]
+                    chunk = ctype + level + chunk[2:]  # keep type same, but set level
+                return chunk
+
+            ctype = chunk[0:1]
             level = b'\xFF'  # FF means unknown compression level
-            if ZLIB_legacy.detect(chunk):
-                ctype = ZLIB.ID
-                chunk = ctype + level + chunk  # get rid of the attic legacy: prepend separate type/level bytes
-            else:
-                ctype = chunk[0:1]
-                chunk = ctype + level + chunk[2:]  # keep type same, but set level
+
             if ctype == ObfuscateSize.ID:
                 # in older borg, we used unusual byte order
                 old_header_fmt = Struct('>I')
@@ -395,7 +400,11 @@ class Archiver:
                 size_bytes = chunk[2:2+length]
                 size = old_header_fmt.unpack(size_bytes)
                 size_bytes = new_header_fmt.pack(size)
-                chunk = chunk[0:2] + size_bytes + chunk[2+length:]
+                compressed = chunk[2+length:]
+                compressed = upgrade_zlib_and_level(compressed)
+                chunk = ctype + level + size_bytes + compressed
+            else:
+                chunk = upgrade_zlib_and_level(chunk)
             return chunk
 
         dry_run = args.dry_run

From f8dbe5b54293c18d3e6668a563c1cc861c0982bd Mon Sep 17 00:00:00 2001
From: Thomas Waldmann <tw@waldmann-edv.de>
Date: Thu, 5 May 2022 19:36:02 +0200
Subject: [PATCH 015/160] cleanup msgpack related str/bytes mess, see #968

see ticket and borg.helpers.msgpack docstring.
---
 src/borg/archive.py            |  16 ++-
 src/borg/archiver.py           |  12 +--
 src/borg/cache_sync/unpack.h   |  36 ++++---
 src/borg/helpers/manifest.py   |  46 ++++-----
 src/borg/helpers/msgpack.py    | 101 +++++++++++++------
 src/borg/item.pyx              | 172 +++++++++++++++++++++++++++------
 src/borg/remote.py             |  49 +++++-----
 src/borg/testsuite/archive.py  |  14 +--
 src/borg/testsuite/archiver.py |  14 +--
 src/borg/testsuite/item.py     |   6 +-
 10 files changed, 311 insertions(+), 155 deletions(-)

diff --git a/src/borg/archive.py b/src/borg/archive.py
index 15cfc5d55..dc244a9f1 100644
--- a/src/borg/archive.py
+++ b/src/borg/archive.py
@@ -34,7 +34,7 @@ from .helpers import Error, IntegrityError, set_ec
 from .platform import uid2user, user2uid, gid2group, group2gid
 from .helpers import parse_timestamp, to_localtime
 from .helpers import OutputTimestamp, format_timedelta, format_file_size, file_status, FileSize
-from .helpers import safe_encode, safe_decode, make_path_safe, remove_surrogates
+from .helpers import safe_encode, make_path_safe, remove_surrogates
 from .helpers import StableDict
 from .helpers import bin_to_hex
 from .helpers import safe_ns
@@ -479,7 +479,6 @@ class Archive:
     def load(self, id):
         self.id = id
         self.metadata = self._load_meta(self.id)
-        self.metadata.cmdline = [safe_decode(arg) for arg in self.metadata.cmdline]
         self.name = self.metadata.name
         self.comment = self.metadata.get('comment', '')
 
@@ -1515,7 +1514,7 @@ class RobustUnpacker:
     """
     def __init__(self, validator, item_keys):
         super().__init__()
-        self.item_keys = [msgpack.packb(name.encode()) for name in item_keys]
+        self.item_keys = [msgpack.packb(name) for name in item_keys]
         self.validator = validator
         self._buffered_data = []
         self._resync = False
@@ -1734,7 +1733,7 @@ class ArchiveChecker:
         # lost manifest on a older borg version than the most recent one that was ever used
         # within this repository (assuming that newer borg versions support more item keys).
         manifest = Manifest(self.key, self.repository)
-        archive_keys_serialized = [msgpack.packb(name.encode()) for name in ARCHIVE_KEYS]
+        archive_keys_serialized = [msgpack.packb(name) for name in ARCHIVE_KEYS]
         pi = ProgressIndicatorPercent(total=len(self.chunks), msg="Rebuilding manifest %6.2f%%", step=0.01,
                                       msgid='check.rebuild_manifest')
         for chunk_id, _ in self.chunks.iteritems():
@@ -1881,9 +1880,9 @@ class ArchiveChecker:
 
             Missing item chunks will be skipped and the msgpack stream will be restarted
             """
-            item_keys = frozenset(key.encode() for key in self.manifest.item_keys)
-            required_item_keys = frozenset(key.encode() for key in REQUIRED_ITEM_KEYS)
-            unpacker = RobustUnpacker(lambda item: isinstance(item, StableDict) and b'path' in item,
+            item_keys = self.manifest.item_keys
+            required_item_keys = REQUIRED_ITEM_KEYS
+            unpacker = RobustUnpacker(lambda item: isinstance(item, StableDict) and 'path' in item,
                                       self.manifest.item_keys)
             _state = 0
 
@@ -1905,7 +1904,7 @@ class ArchiveChecker:
             def valid_item(obj):
                 if not isinstance(obj, StableDict):
                     return False, 'not a dictionary'
-                keys = set(obj)
+                keys = set(k.decode('utf-8', errors='replace') for k in obj)
                 if not required_item_keys.issubset(keys):
                     return False, 'missing required keys: ' + list_keys_safe(required_item_keys - keys)
                 if not keys.issubset(item_keys):
@@ -1991,7 +1990,6 @@ class ArchiveChecker:
                 archive = ArchiveItem(internal_dict=msgpack.unpackb(data))
                 if archive.version != 2:
                     raise Exception('Unknown archive metadata version')
-                archive.cmdline = [safe_decode(arg) for arg in archive.cmdline]
                 items_buffer = ChunkBuffer(self.key)
                 items_buffer.write_chunk = add_callback
                 for item in robust_iterator(archive):
diff --git a/src/borg/archiver.py b/src/borg/archiver.py
index dc0db82f2..acef0db5e 100644
--- a/src/borg/archiver.py
+++ b/src/borg/archiver.py
@@ -55,7 +55,7 @@ try:
     from .helpers import PrefixSpec, GlobSpec, CommentSpec, SortBySpec, FilesCacheMode
     from .helpers import BaseFormatter, ItemFormatter, ArchiveFormatter
     from .helpers import format_timedelta, format_file_size, parse_file_size, format_archive
-    from .helpers import safe_encode, remove_surrogates, bin_to_hex, prepare_dump_dict, eval_escapes
+    from .helpers import remove_surrogates, bin_to_hex, prepare_dump_dict, eval_escapes
     from .helpers import interval, prune_within, prune_split, PRUNING_PATTERNS
     from .helpers import timestamp
     from .helpers import get_cache_dir, os_stat
@@ -1944,12 +1944,12 @@ class Archiver:
                 print('This repository is not encrypted, cannot enable TAM.')
                 return EXIT_ERROR
 
-            if not manifest.tam_verified or not manifest.config.get(b'tam_required', False):
+            if not manifest.tam_verified or not manifest.config.get('tam_required', False):
                 # The standard archive listing doesn't include the archive ID like in borg 1.1.x
                 print('Manifest contents:')
                 for archive_info in manifest.archives.list(sort_by=['ts']):
                     print(format_archive(archive_info), '[%s]' % bin_to_hex(archive_info.id))
-                manifest.config[b'tam_required'] = True
+                manifest.config['tam_required'] = True
                 manifest.write()
                 repository.commit(compact=False)
             if not key.tam_required:
@@ -1972,7 +1972,7 @@ class Archiver:
                 print('Key updated')
                 if hasattr(key, 'find_key'):
                     print('Key location:', key.find_key())
-            manifest.config[b'tam_required'] = False
+            manifest.config['tam_required'] = False
             manifest.write()
             repository.commit(compact=False)
         else:
@@ -2304,7 +2304,7 @@ class Archiver:
         """dump decoded archive metadata (not: data)"""
 
         try:
-            archive_meta_orig = manifest.archives.get_raw_dict()[safe_encode(args.location.archive)]
+            archive_meta_orig = manifest.archives.get_raw_dict()[args.location.archive]
         except KeyError:
             raise Archive.DoesNotExist(args.location.archive)
 
@@ -2321,7 +2321,7 @@ class Archiver:
             fd.write(do_indent(prepare_dump_dict(archive_meta_orig)))
             fd.write(',\n')
 
-            data = key.decrypt(archive_meta_orig[b'id'], repository.get(archive_meta_orig[b'id']))
+            data = key.decrypt(archive_meta_orig['id'], repository.get(archive_meta_orig['id']))
             archive_org_dict = msgpack.unpackb(data, object_hook=StableDict)
 
             fd.write('    "_meta":\n')
diff --git a/src/borg/cache_sync/unpack.h b/src/borg/cache_sync/unpack.h
index f6dd9ca8e..bba566419 100644
--- a/src/borg/cache_sync/unpack.h
+++ b/src/borg/cache_sync/unpack.h
@@ -384,19 +384,11 @@ static inline int unpack_callback_map_end(unpack_user* u)
 
 static inline int unpack_callback_raw(unpack_user* u, const char* b, const char* p, unsigned int length)
 {
-    /* raw = what Borg uses for binary stuff and strings as well */
+    /* raw = what Borg uses for text stuff */
     /* Note: p points to an internal buffer which contains l bytes. */
     (void)b;
 
     switch(u->expect) {
-    case expect_key:
-        if(length != 32) {
-            SET_LAST_ERROR("Incorrect key length");
-            return -1;
-        }
-        memcpy(u->current.key, p, 32);
-        u->expect = expect_size;
-        break;
     case expect_map_key:
         if(length == 6 && !memcmp("chunks", p, 6)) {
             u->expect = expect_chunks_begin;
@@ -409,19 +401,31 @@ static inline int unpack_callback_raw(unpack_user* u, const char* b, const char*
             u->expect = expect_map_item_end;
         }
         break;
-    default:
-        if(u->inside_chunks) {
-            SET_LAST_ERROR("Unexpected bytes in chunks structure");
-            return -1;
-        }
     }
     return 0;
 }
 
 static inline int unpack_callback_bin(unpack_user* u, const char* b, const char* p, unsigned int length)
 {
-    (void)u; (void)b; (void)p; (void)length;
-    UNEXPECTED("bin");
+    /* bin = what Borg uses for binary stuff */
+    /* Note: p points to an internal buffer which contains l bytes. */
+    (void)b;
+
+    switch(u->expect) {
+    case expect_key:
+        if(length != 32) {
+            SET_LAST_ERROR("Incorrect key length");
+            return -1;
+        }
+        memcpy(u->current.key, p, 32);
+        u->expect = expect_size;
+        break;
+    default:
+        if(u->inside_chunks) {
+            SET_LAST_ERROR("Unexpected bytes in chunks structure");
+            return -1;
+        }
+    }
     return 0;
 }
 
diff --git a/src/borg/helpers/manifest.py b/src/borg/helpers/manifest.py
index 425feb4e6..1b9d91fb4 100644
--- a/src/borg/helpers/manifest.py
+++ b/src/borg/helpers/manifest.py
@@ -12,7 +12,7 @@ from ..logger import create_logger
 logger = create_logger()
 
 from .datastruct import StableDict
-from .parseformat import bin_to_hex, safe_encode, safe_decode
+from .parseformat import bin_to_hex
 from .time import parse_timestamp
 from .. import shellpattern
 from ..constants import *  # NOQA
@@ -39,39 +39,35 @@ class Archives(abc.MutableMapping):
     str timestamps or datetime timestamps.
     """
     def __init__(self):
-        # key: encoded archive name, value: dict(b'id': bytes_id, b'time': bytes_iso_ts)
+        # key: str archive name, value: dict('id': bytes_id, 'time': str_iso_ts)
         self._archives = {}
 
     def __len__(self):
         return len(self._archives)
 
     def __iter__(self):
-        return iter(safe_decode(name) for name in self._archives)
+        return iter(self._archives)
 
     def __getitem__(self, name):
         assert isinstance(name, str)
-        _name = safe_encode(name)
-        values = self._archives.get(_name)
+        values = self._archives.get(name)
         if values is None:
             raise KeyError
-        ts = parse_timestamp(values[b'time'].decode())
-        return ArchiveInfo(name=name, id=values[b'id'], ts=ts)
+        ts = parse_timestamp(values['time'])
+        return ArchiveInfo(name=name, id=values['id'], ts=ts)
 
     def __setitem__(self, name, info):
         assert isinstance(name, str)
-        name = safe_encode(name)
         assert isinstance(info, tuple)
         id, ts = info
         assert isinstance(id, bytes)
         if isinstance(ts, datetime):
             ts = ts.replace(tzinfo=None).strftime(ISO_FORMAT)
         assert isinstance(ts, str)
-        ts = ts.encode()
-        self._archives[name] = {b'id': id, b'time': ts}
+        self._archives[name] = {'id': id, 'time': ts}
 
     def __delitem__(self, name):
         assert isinstance(name, str)
-        name = safe_encode(name)
         del self._archives[name]
 
     def list(self, *, glob=None, match_end=r'\Z', sort_by=(), consider_checkpoints=True, first=None, last=None, reverse=False):
@@ -116,8 +112,8 @@ class Archives(abc.MutableMapping):
     def set_raw_dict(self, d):
         """set the dict we get from the msgpack unpacker"""
         for k, v in d.items():
-            assert isinstance(k, bytes)
-            assert isinstance(v, dict) and b'id' in v and b'time' in v
+            assert isinstance(k, str)
+            assert isinstance(v, dict) and 'id' in v and 'time' in v
             self._archives[k] = v
 
     def get_raw_dict(self):
@@ -196,10 +192,10 @@ class Manifest:
         manifest.timestamp = m.get('timestamp')
         manifest.config = m.config
         # valid item keys are whatever is known in the repo or every key we know
-        manifest.item_keys = ITEM_KEYS | frozenset(key.decode() for key in m.get('item_keys', []))
+        manifest.item_keys = ITEM_KEYS | frozenset(m.get('item_keys', []))
 
         if manifest.tam_verified:
-            manifest_required = manifest.config.get(b'tam_required', False)
+            manifest_required = manifest.config.get('tam_required', False)
             security_required = tam_required(repository)
             if manifest_required and not security_required:
                 logger.debug('Manifest is TAM verified and says TAM is required, updating security database...')
@@ -214,32 +210,32 @@ class Manifest:
     def check_repository_compatibility(self, operations):
         for operation in operations:
             assert isinstance(operation, self.Operation)
-            feature_flags = self.config.get(b'feature_flags', None)
+            feature_flags = self.config.get('feature_flags', None)
             if feature_flags is None:
                 return
-            if operation.value.encode() not in feature_flags:
+            if operation.value not in feature_flags:
                 continue
-            requirements = feature_flags[operation.value.encode()]
-            if b'mandatory' in requirements:
-                unsupported = set(requirements[b'mandatory']) - self.SUPPORTED_REPO_FEATURES
+            requirements = feature_flags[operation.value]
+            if 'mandatory' in requirements:
+                unsupported = set(requirements['mandatory']) - self.SUPPORTED_REPO_FEATURES
                 if unsupported:
-                    raise MandatoryFeatureUnsupported([f.decode() for f in unsupported])
+                    raise MandatoryFeatureUnsupported(list(unsupported))
 
     def get_all_mandatory_features(self):
         result = {}
-        feature_flags = self.config.get(b'feature_flags', None)
+        feature_flags = self.config.get('feature_flags', None)
         if feature_flags is None:
             return result
 
         for operation, requirements in feature_flags.items():
-            if b'mandatory' in requirements:
-                result[operation.decode()] = {feature.decode() for feature in requirements[b'mandatory']}
+            if 'mandatory' in requirements:
+                result[operation] = set(requirements['mandatory'])
         return result
 
     def write(self):
         from ..item import ManifestItem
         if self.key.tam_required:
-            self.config[b'tam_required'] = True
+            self.config['tam_required'] = True
         # self.timestamp needs to be strictly monotonically increasing. Clocks often are not set correctly
         if self.timestamp is None:
             self.timestamp = datetime.utcnow().strftime(ISO_FORMAT)
diff --git a/src/borg/helpers/msgpack.py b/src/borg/helpers/msgpack.py
index 411f00fec..5a2edecd6 100644
--- a/src/borg/helpers/msgpack.py
+++ b/src/borg/helpers/msgpack.py
@@ -1,21 +1,56 @@
+"""
+wrapping msgpack
+================
+
+Due to the planned breaking api changes in upstream msgpack, we wrap it the way we need it -
+to avoid having lots of clutter in the calling code. see tickets #968 and #3632.
+
+Packing
+-------
+- use_bin_type = True (used by borg since borg 1.3)
+  This is used to generate output according to new msgpack 2.0 spec.
+  This cleanly keeps bytes and str types apart.
+
+- use_bin_type = False (used by borg < 1.3)
+  This creates output according to the older msgpack spec.
+  BAD: str and bytes were packed into same "raw" representation.
+
+- unicode_errors = 'surrogateescape'
+  Guess backup applications are one of the rare cases when this needs to be used.
+  It is needed because borg also needs to deal with data that does not cleanly encode/decode using utf-8.
+  There's a lot of crap out there, e.g. in filenames and as a backup tool, we must keep them as good as possible.
+
+Unpacking
+---------
+- raw = True (the old way, used by borg <= 1.3)
+  This is currently still needed to not try to decode "raw" msgpack objects.
+  These could come either from str (new or old msgpack) or bytes (old msgpack).
+  Thus, we basically must know what we want and either keep the bytes we get
+  or decode them to str, if we want str.
+
+- raw = False (the new way)
+  This can be used in future, when we do not have to deal with data any more that was packed the old way.
+  It will then unpack according to the msgpack 2.0 spec format and directly output bytes or str.
+
+- unicode_errors = 'surrogateescape' -> see description above (will be used when raw is False).
+
+As of borg 1.3, we have the first part on the way to fix the msgpack str/bytes mess, #968.
+borg now still needs to **read** old repos, archives, keys, ... so we can not yet fix it completely.
+But from now on, borg only **writes** new data according to the new msgpack spec,
+thus we can complete the fix for #968 in a later borg release.
+
+current way in msgpack terms
+----------------------------
+
+- pack with use_bin_type=True (according to msgpack 2.0 spec)
+- packs str -> raw and bytes -> bin
+- unpack with raw=True (aka "the old way")
+- unpacks raw to bytes (thus we always need to decode manually if we want str)
+"""
+
 from .datastruct import StableDict
 from ..constants import *  # NOQA
 
-# wrapping msgpack ---------------------------------------------------------------------------------------------------
-#
-# due to the planned breaking api changes in upstream msgpack, we wrap it the way we need it -
-# to avoid having lots of clutter in the calling code. see tickets #968 and #3632.
-#
-# Packing
-# -------
-# use_bin_type = False is needed to generate the old msgpack format (not msgpack 2.0 spec) as borg always did.
-# unicode_errors = None is needed because usage of it is deprecated
-#
-# Unpacking
-# ---------
-# raw = True is needed to unpack the old msgpack format to bytes (not str, about the decoding see item.pyx).
-# unicode_errors = None is needed because usage of it is deprecated
-
 from msgpack import Packer as mp_Packer
 from msgpack import packb as mp_packb
 from msgpack import pack as mp_pack
@@ -30,6 +65,10 @@ from msgpack import OutOfData
 
 version = mp_version
 
+USE_BIN_TYPE = True
+RAW = True  # should become False later when we do not need to read old stuff any more
+UNICODE_ERRORS = 'surrogateescape'  # previously done by safe_encode, safe_decode
+
 
 class PackException(Exception):
     """Exception while msgpack packing"""
@@ -40,10 +79,10 @@ class UnpackException(Exception):
 
 
 class Packer(mp_Packer):
-    def __init__(self, *, default=None, unicode_errors=None,
-                 use_single_float=False, autoreset=True, use_bin_type=False,
+    def __init__(self, *, default=None, unicode_errors=UNICODE_ERRORS,
+                 use_single_float=False, autoreset=True, use_bin_type=USE_BIN_TYPE,
                  strict_types=False):
-        assert unicode_errors is None
+        assert unicode_errors == UNICODE_ERRORS
         super().__init__(default=default, unicode_errors=unicode_errors,
                          use_single_float=use_single_float, autoreset=autoreset, use_bin_type=use_bin_type,
                          strict_types=strict_types)
@@ -55,16 +94,16 @@ class Packer(mp_Packer):
             raise PackException(e)
 
 
-def packb(o, *, use_bin_type=False, unicode_errors=None, **kwargs):
-    assert unicode_errors is None
+def packb(o, *, use_bin_type=USE_BIN_TYPE, unicode_errors=UNICODE_ERRORS, **kwargs):
+    assert unicode_errors == UNICODE_ERRORS
     try:
         return mp_packb(o, use_bin_type=use_bin_type, unicode_errors=unicode_errors, **kwargs)
     except Exception as e:
         raise PackException(e)
 
 
-def pack(o, stream, *, use_bin_type=False, unicode_errors=None, **kwargs):
-    assert unicode_errors is None
+def pack(o, stream, *, use_bin_type=USE_BIN_TYPE, unicode_errors=UNICODE_ERRORS, **kwargs):
+    assert unicode_errors == UNICODE_ERRORS
     try:
         return mp_pack(o, stream, use_bin_type=use_bin_type, unicode_errors=unicode_errors, **kwargs)
     except Exception as e:
@@ -72,13 +111,13 @@ def pack(o, stream, *, use_bin_type=False, unicode_errors=None, **kwargs):
 
 
 class Unpacker(mp_Unpacker):
-    def __init__(self, file_like=None, *, read_size=0, use_list=True, raw=True,
+    def __init__(self, file_like=None, *, read_size=0, use_list=True, raw=RAW,
                  object_hook=None, object_pairs_hook=None, list_hook=None,
-                 unicode_errors=None, max_buffer_size=0,
+                 unicode_errors=UNICODE_ERRORS, max_buffer_size=0,
                  ext_hook=ExtType,
                  strict_map_key=False):
-        assert raw is True
-        assert unicode_errors is None
+        assert raw == RAW
+        assert unicode_errors == UNICODE_ERRORS
         kw = dict(file_like=file_like, read_size=read_size, use_list=use_list, raw=raw,
                   object_hook=object_hook, object_pairs_hook=object_pairs_hook, list_hook=list_hook,
                   unicode_errors=unicode_errors, max_buffer_size=max_buffer_size,
@@ -105,10 +144,11 @@ class Unpacker(mp_Unpacker):
     next = __next__
 
 
-def unpackb(packed, *, raw=True, unicode_errors=None,
+def unpackb(packed, *, raw=RAW, unicode_errors=UNICODE_ERRORS,
             strict_map_key=False,
             **kwargs):
-    assert unicode_errors is None
+    assert raw == RAW
+    assert unicode_errors == UNICODE_ERRORS
     try:
         kw = dict(raw=raw, unicode_errors=unicode_errors,
                   strict_map_key=strict_map_key)
@@ -118,10 +158,11 @@ def unpackb(packed, *, raw=True, unicode_errors=None,
         raise UnpackException(e)
 
 
-def unpack(stream, *, raw=True, unicode_errors=None,
+def unpack(stream, *, raw=RAW, unicode_errors=UNICODE_ERRORS,
            strict_map_key=False,
            **kwargs):
-    assert unicode_errors is None
+    # assert raw == RAW
+    assert unicode_errors == UNICODE_ERRORS
     try:
         kw = dict(raw=raw, unicode_errors=unicode_errors,
                   strict_map_key=strict_map_key)
diff --git a/src/borg/item.pyx b/src/borg/item.pyx
index 9ea76f2de..89f476c1a 100644
--- a/src/borg/item.pyx
+++ b/src/borg/item.pyx
@@ -2,7 +2,6 @@ import stat
 from collections import namedtuple
 
 from .constants import ITEM_KEYS, ARCHIVE_KEYS
-from .helpers import safe_encode, safe_decode
 from .helpers import StableDict
 from .helpers import format_file_size
 from .helpers.msgpack import timestamp_to_int, int_to_timestamp
@@ -16,6 +15,51 @@ cdef extern from "_item.c":
 API_VERSION = '1.2_01'
 
 
+def fix_key(data, key):
+    """if k is a bytes-typed key, migrate key/value to a str-typed key in dict data"""
+    if isinstance(key, bytes):
+        value = data.pop(key)
+        key = key.decode()
+        data[key] = value
+    assert isinstance(key, str)
+    return key
+
+
+def fix_str_value(data, key, errors='surrogateescape'):
+    """makes sure that data[key] is a str (decode if it is bytes)"""
+    assert isinstance(key, str)  # fix_key must be called first
+    value = data[key]
+    if isinstance(value, bytes):
+        value = value.decode('utf-8', errors=errors)
+        data[key] = value
+    assert isinstance(value, str)
+    return value
+
+
+def fix_list_of_str(t):
+    """make sure we have a list of str"""
+    assert isinstance(t, (tuple, list))
+    l = [e.decode() if isinstance(e, bytes) else e for e in t]
+    assert all(isinstance(e, str) for e in l), repr(l)
+    return l
+
+
+def fix_tuple_of_str(t):
+    """make sure we have a tuple of str"""
+    assert isinstance(t, (tuple, list))
+    t = tuple(e.decode() if isinstance(e, bytes) else e for e in t)
+    assert all(isinstance(e, str) for e in t), repr(t)
+    return t
+
+
+def fix_tuple_of_str_and_int(t):
+    """make sure we have a tuple of str"""
+    assert isinstance(t, (tuple, list))
+    t = tuple(e.decode() if isinstance(e, bytes) else e for e in t)
+    assert all(isinstance(e, (str, int)) for e in t), repr(t)
+    return t
+
+
 class PropDict:
     """
     Manage a dictionary via properties.
@@ -155,10 +199,10 @@ class Item(PropDict):
 
     # properties statically defined, so that IDEs can know their names:
 
-    path = PropDict._make_property('path', str, 'surrogate-escaped str', encode=safe_encode, decode=safe_decode)
-    source = PropDict._make_property('source', str, 'surrogate-escaped str', encode=safe_encode, decode=safe_decode)
-    user = PropDict._make_property('user', (str, type(None)), 'surrogate-escaped str or None', encode=safe_encode, decode=safe_decode)
-    group = PropDict._make_property('group', (str, type(None)), 'surrogate-escaped str or None', encode=safe_encode, decode=safe_decode)
+    path = PropDict._make_property('path', str, 'surrogate-escaped str')
+    source = PropDict._make_property('source', str, 'surrogate-escaped str')
+    user = PropDict._make_property('user', (str, type(None)), 'surrogate-escaped str or None')
+    group = PropDict._make_property('group', (str, type(None)), 'surrogate-escaped str or None')
 
     acl_access = PropDict._make_property('acl_access', bytes)
     acl_default = PropDict._make_property('acl_default', bytes)
@@ -290,6 +334,14 @@ class Item(PropDict):
         except AttributeError:
             return False
 
+    def update_internal(self, d):
+        # legacy support for migration (data from old msgpacks comes in as bytes always, but sometimes we want str)
+        for k, v in list(d.items()):
+            k = fix_key(d, k)
+            if k in ('path', 'source', 'user', 'group'):
+                v = fix_str_value(d, k)
+            self._dict[k] = v
+
 
 class EncryptedKey(PropDict):
     """
@@ -309,7 +361,7 @@ class EncryptedKey(PropDict):
     __slots__ = ("_dict", )  # avoid setting attributes not supported by properties
 
     version = PropDict._make_property('version', int)
-    algorithm = PropDict._make_property('algorithm', str, encode=str.encode, decode=bytes.decode)
+    algorithm = PropDict._make_property('algorithm', str)
     iterations = PropDict._make_property('iterations', int)
     salt = PropDict._make_property('salt', bytes)
     hash = PropDict._make_property('hash', bytes)
@@ -317,7 +369,17 @@ class EncryptedKey(PropDict):
     argon2_time_cost = PropDict._make_property('argon2_time_cost', int)
     argon2_memory_cost = PropDict._make_property('argon2_memory_cost', int)
     argon2_parallelism = PropDict._make_property('argon2_parallelism', int)
-    argon2_type = PropDict._make_property('argon2_type', str, encode=str.encode, decode=bytes.decode)
+    argon2_type = PropDict._make_property('argon2_type', str)
+
+    def update_internal(self, d):
+        # legacy support for migration (data from old msgpacks comes in as bytes always, but sometimes we want str)
+        for k, v in list(d.items()):
+            k = fix_key(d, k)
+            if k == 'version':
+                assert isinstance(v, int)
+            if k in ('algorithm', 'argon2_type'):
+                v = fix_str_value(d, k)
+            self._dict[k] = v
 
 
 class Key(PropDict):
@@ -344,17 +406,13 @@ class Key(PropDict):
     chunk_seed = PropDict._make_property('chunk_seed', int)
     tam_required = PropDict._make_property('tam_required', bool)
 
-
-def tuple_encode(t):
-    """encode a tuple that might contain str items"""
-    # we have str, but want to give bytes to msgpack.pack
-    return tuple(safe_encode(e) if isinstance(e, str) else e for e in t)
-
-
-def tuple_decode(t):
-    """decode a tuple that might contain bytes items"""
-    # we get bytes objects from msgpack.unpack, but want str
-    return tuple(safe_decode(e) if isinstance(e, bytes) else e for e in t)
+    def update_internal(self, d):
+        # legacy support for migration (data from old msgpacks comes in as bytes always, but sometimes we want str)
+        for k, v in list(d.items()):
+            k = fix_key(d, k)
+            if k == 'version':
+                assert isinstance(v, int)
+            self._dict[k] = v
 
 
 class ArchiveItem(PropDict):
@@ -374,15 +432,15 @@ class ArchiveItem(PropDict):
     __slots__ = ("_dict", )  # avoid setting attributes not supported by properties
 
     version = PropDict._make_property('version', int)
-    name = PropDict._make_property('name', str, 'surrogate-escaped str', encode=safe_encode, decode=safe_decode)
+    name = PropDict._make_property('name', str, 'surrogate-escaped str')
     items = PropDict._make_property('items', list)
     cmdline = PropDict._make_property('cmdline', list)  # list of s-e-str
-    hostname = PropDict._make_property('hostname', str, 'surrogate-escaped str', encode=safe_encode, decode=safe_decode)
-    username = PropDict._make_property('username', str, 'surrogate-escaped str', encode=safe_encode, decode=safe_decode)
-    time = PropDict._make_property('time', str, 'surrogate-escaped str', encode=safe_encode, decode=safe_decode)
-    time_end = PropDict._make_property('time_end', str, 'surrogate-escaped str', encode=safe_encode, decode=safe_decode)
-    comment = PropDict._make_property('comment', str, 'surrogate-escaped str', encode=safe_encode, decode=safe_decode)
-    chunker_params = PropDict._make_property('chunker_params', tuple, 'chunker-params tuple', encode=tuple_encode, decode=tuple_decode)
+    hostname = PropDict._make_property('hostname', str, 'surrogate-escaped str')
+    username = PropDict._make_property('username', str, 'surrogate-escaped str')
+    time = PropDict._make_property('time', str)
+    time_end = PropDict._make_property('time_end', str)
+    comment = PropDict._make_property('comment', str, 'surrogate-escaped str')
+    chunker_params = PropDict._make_property('chunker_params', tuple)
     recreate_cmdline = PropDict._make_property('recreate_cmdline', list)  # list of s-e-str
     # recreate_source_id, recreate_args, recreate_partial_chunks were used in 1.1.0b1 .. b2
     recreate_source_id = PropDict._make_property('recreate_source_id', bytes)
@@ -395,6 +453,22 @@ class ArchiveItem(PropDict):
     csize_parts = PropDict._make_property('csize_parts', int)
     nfiles_parts = PropDict._make_property('nfiles_parts', int)
 
+    def update_internal(self, d):
+        # legacy support for migration (data from old msgpacks comes in as bytes always, but sometimes we want str)
+        for k, v in list(d.items()):
+            k = fix_key(d, k)
+            if k == 'version':
+                assert isinstance(v, int)
+            if k in ('name', 'hostname', 'username', 'comment'):
+                v = fix_str_value(d, k)
+            if k in ('time', 'time_end'):
+                v = fix_str_value(d, k, 'replace')
+            if k == 'chunker_params':
+                v = fix_tuple_of_str_and_int(v)
+            if k in ('cmdline', 'recreate_cmdline'):
+                v = fix_list_of_str(v)
+            self._dict[k] = v
+
 
 class ManifestItem(PropDict):
     """
@@ -413,10 +487,52 @@ class ManifestItem(PropDict):
     __slots__ = ("_dict", )  # avoid setting attributes not supported by properties
 
     version = PropDict._make_property('version', int)
-    archives = PropDict._make_property('archives', dict)  # name -> dict
-    timestamp = PropDict._make_property('timestamp', str, 'surrogate-escaped str', encode=safe_encode, decode=safe_decode)
+    archives = PropDict._make_property('archives', dict, 'dict of str -> dict')  # name -> dict
+    timestamp = PropDict._make_property('timestamp', str)
     config = PropDict._make_property('config', dict)
-    item_keys = PropDict._make_property('item_keys', tuple)
+    item_keys = PropDict._make_property('item_keys', tuple, 'tuple of str')
+
+    def update_internal(self, d):
+        # legacy support for migration (data from old msgpacks comes in as bytes always, but sometimes we want str)
+        for k, v in list(d.items()):
+            k = fix_key(d, k)
+            if k == 'version':
+                assert isinstance(v, int)
+            if k == 'archives':
+                ad = v
+                assert isinstance(ad, dict)
+                for ak, av in list(ad.items()):
+                    ak = fix_key(ad, ak)
+                    assert isinstance(av, dict)
+                    for ik, iv in list(av.items()):
+                        ik = fix_key(av, ik)
+                    assert set(av) == {'id', 'time'}
+                    assert isinstance(av['id'], bytes)
+                    fix_str_value(av, 'time')
+            if k == 'timestamp':
+                v = fix_str_value(d, k, 'replace')
+            if k == 'config':
+                cd = v
+                assert isinstance(cd, dict)
+                for ck, cv in list(cd.items()):
+                    ck = fix_key(cd, ck)
+                    if ck == 'tam_required':
+                        assert isinstance(cv, bool)
+                    if ck == 'feature_flags':
+                        assert isinstance(cv, dict)
+                        ops = {'read', 'check', 'write', 'delete'}
+                        for op, specs in list(cv.items()):
+                            op = fix_key(cv, op)
+                            assert op in ops
+                            for speck, specv in list(specs.items()):
+                                speck = fix_key(specs, speck)
+                                if speck == 'mandatory':
+                                    specs[speck] = fix_tuple_of_str(specv)
+                        assert set(cv).issubset(ops)
+            if k == 'item_keys':
+                v = fix_tuple_of_str(v)
+            self._dict[k] = v
+
 
 class ItemDiff:
     """
diff --git a/src/borg/remote.py b/src/borg/remote.py
index 2870d71d9..8de302871 100644
--- a/src/borg/remote.py
+++ b/src/borg/remote.py
@@ -38,7 +38,8 @@ logger = create_logger(__name__)
 
 RPC_PROTOCOL_VERSION = 2
 BORG_VERSION = parse_version(__version__)
-MSGID, MSG, ARGS, RESULT = b'i', b'm', b'a', b'r'
+MSGID, MSG, ARGS, RESULT = 'i', 'm', 'a', 'r'  # pack
+MSGIDB, MSGB, ARGSB, RESULTB = b'i', b'm', b'a', b'r'  # unpack
 
 MAX_INFLIGHT = 100
 
@@ -216,9 +217,9 @@ class RepositoryServer:  # pragma: no cover
                 for unpacked in unpacker:
                     if isinstance(unpacked, dict):
                         dictFormat = True
-                        msgid = unpacked[MSGID]
-                        method = unpacked[MSG].decode()
-                        args = decode_keys(unpacked[ARGS])
+                        msgid = unpacked[MSGIDB]
+                        method = unpacked[MSGB].decode()
+                        args = decode_keys(unpacked[ARGSB])
                     elif isinstance(unpacked, tuple) and len(unpacked) == 4:
                         dictFormat = False
                         # The first field 'type' was always 1 and has always been ignored
@@ -256,21 +257,21 @@ class RepositoryServer:  # pragma: no cover
 
                             try:
                                 msg = msgpack.packb({MSGID: msgid,
-                                                    b'exception_class': e.__class__.__name__,
-                                                    b'exception_args': e.args,
-                                                    b'exception_full': ex_full,
-                                                    b'exception_short': ex_short,
-                                                    b'exception_trace': ex_trace,
-                                                    b'sysinfo': sysinfo()})
+                                                    'exception_class': e.__class__.__name__,
+                                                    'exception_args': e.args,
+                                                    'exception_full': ex_full,
+                                                    'exception_short': ex_short,
+                                                    'exception_trace': ex_trace,
+                                                    'sysinfo': sysinfo()})
                             except TypeError:
                                 msg = msgpack.packb({MSGID: msgid,
-                                                    b'exception_class': e.__class__.__name__,
-                                                    b'exception_args': [x if isinstance(x, (str, bytes, int)) else None
-                                                                        for x in e.args],
-                                                    b'exception_full': ex_full,
-                                                    b'exception_short': ex_short,
-                                                    b'exception_trace': ex_trace,
-                                                    b'sysinfo': sysinfo()})
+                                                    'exception_class': e.__class__.__name__,
+                                                    'exception_args': [x if isinstance(x, (str, bytes, int)) else None
+                                                                       for x in e.args],
+                                                    'exception_full': ex_full,
+                                                    'exception_short': ex_short,
+                                                    'exception_trace': ex_trace,
+                                                    'sysinfo': sysinfo()})
 
                             os_write(stdout_fd, msg)
                         else:
@@ -570,7 +571,7 @@ class RemoteRepository:
         try:
             try:
                 version = self.call('negotiate', {'client_data': {
-                    b'client_version': BORG_VERSION,
+                    'client_version': BORG_VERSION,
                 }})
             except ConnectionClosed:
                 raise ConnectionClosedWithHint('Is borg working on the server?') from None
@@ -791,7 +792,7 @@ This problem will go away as soon as the server has been upgraded to 1.0.7+.
                     if b'exception_class' in unpacked:
                         handle_error(unpacked)
                     else:
-                        yield unpacked[RESULT]
+                        yield unpacked[RESULTB]
                         if not waiting_for and not calls:
                             return
                 except KeyError:
@@ -811,7 +812,7 @@ This problem will go away as soon as the server has been upgraded to 1.0.7+.
                         if b'exception_class' in unpacked:
                             handle_error(unpacked)
                         else:
-                            yield unpacked[RESULT]
+                            yield unpacked[RESULTB]
             if self.to_send or ((calls or self.preload_ids) and len(waiting_for) < MAX_INFLIGHT):
                 w_fds = [self.stdin_fd]
             else:
@@ -828,15 +829,15 @@ This problem will go away as soon as the server has been upgraded to 1.0.7+.
                     self.unpacker.feed(data)
                     for unpacked in self.unpacker:
                         if isinstance(unpacked, dict):
-                            msgid = unpacked[MSGID]
+                            msgid = unpacked[MSGIDB]
                         elif isinstance(unpacked, tuple) and len(unpacked) == 4:
                             # The first field 'type' was always 1 and has always been ignored
                             _, msgid, error, res = unpacked
                             if error:
                                 # ignore res, because it is only a fixed string anyway.
-                                unpacked = {MSGID: msgid, b'exception_class': error}
+                                unpacked = {MSGIDB: msgid, b'exception_class': error}
                             else:
-                                unpacked = {MSGID: msgid, RESULT: res}
+                                unpacked = {MSGIDB: msgid, RESULTB: res}
                         else:
                             raise UnexpectedRPCDataFormatFromServer(data)
                         if msgid in self.ignore_responses:
@@ -847,7 +848,7 @@ This problem will go away as soon as the server has been upgraded to 1.0.7+.
                             else:
                                 # we currently do not have async result values except "None",
                                 # so we do not add them into async_responses.
-                                if unpacked[RESULT] is not None:
+                                if unpacked[RESULTB] is not None:
                                     self.async_responses[msgid] = unpacked
                         else:
                             self.responses[msgid] = unpacked
diff --git a/src/borg/testsuite/archive.py b/src/borg/testsuite/archive.py
index 3f8535ff5..0eed9f7e8 100644
--- a/src/borg/testsuite/archive.py
+++ b/src/borg/testsuite/archive.py
@@ -186,8 +186,8 @@ class RobustUnpackerTestCase(BaseTestCase):
         return result
 
     def test_extra_garbage_no_sync(self):
-        chunks = [(False, [self.make_chunks([b'foo', b'bar'])]),
-                  (False, [b'garbage'] + [self.make_chunks([b'boo', b'baz'])])]
+        chunks = [(False, [self.make_chunks(['foo', 'bar'])]),
+                  (False, [b'garbage'] + [self.make_chunks(['boo', 'baz'])])]
         result = self.process(chunks)
         self.assert_equal(result, [
             {b'path': b'foo'}, {b'path': b'bar'},
@@ -203,19 +203,19 @@ class RobustUnpackerTestCase(BaseTestCase):
         return parts
 
     def test_correct_stream(self):
-        chunks = self.split(self.make_chunks([b'foo', b'bar', b'boo', b'baz']), 2)
+        chunks = self.split(self.make_chunks(['foo', 'bar', 'boo', 'baz']), 2)
         input = [(False, chunks)]
         result = self.process(input)
         self.assert_equal(result, [{b'path': b'foo'}, {b'path': b'bar'}, {b'path': b'boo'}, {b'path': b'baz'}])
 
     def test_missing_chunk(self):
-        chunks = self.split(self.make_chunks([b'foo', b'bar', b'boo', b'baz']), 4)
+        chunks = self.split(self.make_chunks(['foo', 'bar', 'boo', 'baz']), 4)
         input = [(False, chunks[:3]), (True, chunks[4:])]
         result = self.process(input)
         self.assert_equal(result, [{b'path': b'foo'}, {b'path': b'boo'}, {b'path': b'baz'}])
 
     def test_corrupt_chunk(self):
-        chunks = self.split(self.make_chunks([b'foo', b'bar', b'boo', b'baz']), 4)
+        chunks = self.split(self.make_chunks(['foo', 'bar', 'boo', 'baz']), 4)
         input = [(False, chunks[:3]), (True, [b'gar', b'bage'] + chunks[3:])]
         result = self.process(input)
         self.assert_equal(result, [{b'path': b'foo'}, {b'path': b'boo'}, {b'path': b'baz'}])
@@ -242,7 +242,7 @@ IK = sorted(list(ITEM_KEYS))
 
 @pytest.mark.parametrize('packed',
     [msgpack.packb(o) for o in [
-        {b'path': b'/a/b/c'},  # small (different msgpack mapping type!)
+        {'path': b'/a/b/c'},  # small (different msgpack mapping type!)
         OrderedDict((k, b'') for k in IK),  # as big (key count) as it gets
         OrderedDict((k, b'x' * 1000) for k in IK),  # as big (key count and volume) as it gets
     ]])
@@ -251,7 +251,7 @@ def test_valid_msgpacked_items(packed, item_keys_serialized):
 
 
 def test_key_length_msgpacked_items():
-    key = b'x' * 32  # 31 bytes is the limit for fixstr msgpack type
+    key = 'x' * 32  # 31 bytes is the limit for fixstr msgpack type
     data = {key: b''}
     item_keys_serialized = [msgpack.packb(key), ]
     assert valid_msgpacked_dict(msgpack.packb(data), item_keys_serialized)
diff --git a/src/borg/testsuite/archiver.py b/src/borg/testsuite/archiver.py
index 32feeb44e..f3315b676 100644
--- a/src/borg/testsuite/archiver.py
+++ b/src/borg/testsuite/archiver.py
@@ -1810,7 +1810,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
     def add_unknown_feature(self, operation):
         with Repository(self.repository_path, exclusive=True) as repository:
             manifest, key = Manifest.load(repository, Manifest.NO_OPERATION_CHECK)
-            manifest.config[b'feature_flags'] = {operation.value.encode(): {b'mandatory': [b'unknown-feature']}}
+            manifest.config['feature_flags'] = {operation.value: {'mandatory': ['unknown-feature']}}
             manifest.write()
             repository.commit(compact=False)
 
@@ -3640,13 +3640,13 @@ id: 2 / e29442 3506da 4e1ea7 / 25f62a 5a3d41 - 02
 
         with Repository(self.repository_path) as repository:
             key = msgpack.unpackb(a2b_base64(repository.load_key()))
-            assert key[b'algorithm'] == expected_algorithm
+            assert key[b'algorithm'] == expected_algorithm.encode()
 
     def test_change_passphrase_does_not_change_algorithm_argon2(self):
-        self.verify_change_passphrase_does_not_change_algorithm('argon2', b'argon2 chacha20-poly1305')
+        self.verify_change_passphrase_does_not_change_algorithm('argon2', 'argon2 chacha20-poly1305')
 
     def test_change_passphrase_does_not_change_algorithm_pbkdf2(self):
-        self.verify_change_passphrase_does_not_change_algorithm('pbkdf2', b'sha256')
+        self.verify_change_passphrase_does_not_change_algorithm('pbkdf2', 'sha256')
 
     def verify_change_location_does_not_change_algorithm(self, given_algorithm, expected_algorithm):
         self.cmd('init', '--encryption=keyfile', '--key-algorithm', given_algorithm, self.repository_location)
@@ -3655,13 +3655,13 @@ id: 2 / e29442 3506da 4e1ea7 / 25f62a 5a3d41 - 02
 
         with Repository(self.repository_path) as repository:
             key = msgpack.unpackb(a2b_base64(repository.load_key()))
-            assert key[b'algorithm'] == expected_algorithm
+            assert key[b'algorithm'] == expected_algorithm.encode()
 
     def test_change_location_does_not_change_algorithm_argon2(self):
-        self.verify_change_location_does_not_change_algorithm('argon2', b'argon2 chacha20-poly1305')
+        self.verify_change_location_does_not_change_algorithm('argon2', 'argon2 chacha20-poly1305')
 
     def test_change_location_does_not_change_algorithm_pbkdf2(self):
-        self.verify_change_location_does_not_change_algorithm('pbkdf2', b'sha256')
+        self.verify_change_location_does_not_change_algorithm('pbkdf2', 'sha256')
 
     def test_key_change_algorithm(self):
         self.cmd('init', '--encryption=repokey', '--key-algorithm=pbkdf2', self.repository_location)
diff --git a/src/borg/testsuite/item.py b/src/borg/testsuite/item.py
index 80b38edce..94167e7ea 100644
--- a/src/borg/testsuite/item.py
+++ b/src/borg/testsuite/item.py
@@ -102,7 +102,7 @@ def test_item_se_str_property():
     item = Item()
     item.path = '/a/b/c'
     assert item.path == '/a/b/c'
-    assert item.as_dict() == {'path': b'/a/b/c'}
+    assert item.as_dict() == {'path': '/a/b/c'}
     del item.path
     assert item.as_dict() == {}
     with pytest.raises(TypeError):
@@ -111,11 +111,11 @@ def test_item_se_str_property():
     # non-utf-8 path, needing surrogate-escaping for latin-1 u-umlaut
     item = Item(internal_dict={'path': b'/a/\xfc/c'})
     assert item.path == '/a/\udcfc/c'  # getting a surrogate-escaped representation
-    assert item.as_dict() == {'path': b'/a/\xfc/c'}
+    assert item.as_dict() == {'path': '/a/\udcfc/c'}
     del item.path
     assert 'path' not in item
     item.path = '/a/\udcfc/c'  # setting using a surrogate-escaped representation
-    assert item.as_dict() == {'path': b'/a/\xfc/c'}
+    assert item.as_dict() == {'path': '/a/\udcfc/c'}
 
 
 def test_item_list_property():

From 8e87f1111b02f35c2ac14c0605b60ccd8db486b8 Mon Sep 17 00:00:00 2001
From: Thomas Waldmann <tw@waldmann-edv.de>
Date: Fri, 6 May 2022 03:59:10 +0200
Subject: [PATCH 016/160] cleanup msgpack related str/bytes mess, fixes #968

see ticket and borg.helpers.msgpack docstring.

this changeset implements the full migration to
msgpack 2.0 spec (use_bin_type=True, raw=False).

still needed compat to the past is done via want_bytes decoder in borg.item.
---
 src/borg/archive.py              |  7 +--
 src/borg/archiver.py             |  2 +-
 src/borg/crypto/key.py           | 10 ++---
 src/borg/helpers/msgpack.py      | 34 +++++++-------
 src/borg/item.pyx                | 35 +++++++++------
 src/borg/remote.py               | 77 +++++++++++++++-----------------
 src/borg/repository.py           | 44 +++++++++---------
 src/borg/testsuite/archive.py    | 14 +++---
 src/borg/testsuite/archiver.py   | 10 ++---
 src/borg/testsuite/key.py        | 16 +++----
 src/borg/testsuite/repository.py |  4 +-
 11 files changed, 124 insertions(+), 129 deletions(-)

diff --git a/src/borg/archive.py b/src/borg/archive.py
index dc244a9f1..ff6ca7ce6 100644
--- a/src/borg/archive.py
+++ b/src/borg/archive.py
@@ -1718,13 +1718,10 @@ class ArchiveChecker:
 
         Iterates through all objects in the repository looking for archive metadata blocks.
         """
-        required_archive_keys = frozenset(key.encode() for key in REQUIRED_ARCHIVE_KEYS)
-
         def valid_archive(obj):
             if not isinstance(obj, dict):
                 return False
-            keys = set(obj)
-            return required_archive_keys.issubset(keys)
+            return REQUIRED_ARCHIVE_KEYS.issubset(obj)
 
         logger.info('Rebuilding missing manifest, this might take some time...')
         # as we have lost the manifest, we do not know any more what valid item keys we had.
@@ -1904,7 +1901,7 @@ class ArchiveChecker:
             def valid_item(obj):
                 if not isinstance(obj, StableDict):
                     return False, 'not a dictionary'
-                keys = set(k.decode('utf-8', errors='replace') for k in obj)
+                keys = set(obj)
                 if not required_item_keys.issubset(keys):
                     return False, 'missing required keys: ' + list_keys_safe(required_item_keys - keys)
                 if not keys.issubset(item_keys):
diff --git a/src/borg/archiver.py b/src/borg/archiver.py
index acef0db5e..a91e43c54 100644
--- a/src/borg/archiver.py
+++ b/src/borg/archiver.py
@@ -2331,7 +2331,7 @@ class Archiver:
 
             unpacker = msgpack.Unpacker(use_list=False, object_hook=StableDict)
             first = True
-            for item_id in archive_org_dict[b'items']:
+            for item_id in archive_org_dict['items']:
                 data = key.decrypt(item_id, repository.get(item_id))
                 unpacker.feed(data)
                 for item in unpacker:
diff --git a/src/borg/crypto/key.py b/src/borg/crypto/key.py
index 6ca6fbac0..15df53d00 100644
--- a/src/borg/crypto/key.py
+++ b/src/borg/crypto/key.py
@@ -232,24 +232,24 @@ class KeyBase:
         unpacker = get_limited_unpacker('manifest')
         unpacker.feed(data)
         unpacked = unpacker.unpack()
-        if b'tam' not in unpacked:
+        if 'tam' not in unpacked:
             if tam_required:
                 raise TAMRequiredError(self.repository._location.canonical_path())
             else:
                 logger.debug('TAM not found and not required')
                 return unpacked, False
-        tam = unpacked.pop(b'tam', None)
+        tam = unpacked.pop('tam', None)
         if not isinstance(tam, dict):
             raise TAMInvalid()
-        tam_type = tam.get(b'type', b'<none>').decode('ascii', 'replace')
+        tam_type = tam.get('type', '<none>')
         if tam_type != 'HKDF_HMAC_SHA512':
             if tam_required:
                 raise TAMUnsupportedSuiteError(repr(tam_type))
             else:
                 logger.debug('Ignoring TAM made with unsupported suite, since TAM is not required: %r', tam_type)
                 return unpacked, False
-        tam_hmac = tam.get(b'hmac')
-        tam_salt = tam.get(b'salt')
+        tam_hmac = tam.get('hmac')
+        tam_salt = tam.get('salt')
         if not isinstance(tam_salt, bytes) or not isinstance(tam_hmac, bytes):
             raise TAMInvalid()
         offset = data.index(tam_hmac)
diff --git a/src/borg/helpers/msgpack.py b/src/borg/helpers/msgpack.py
index 5a2edecd6..268ee30e7 100644
--- a/src/borg/helpers/msgpack.py
+++ b/src/borg/helpers/msgpack.py
@@ -2,8 +2,7 @@
 wrapping msgpack
 ================
 
-Due to the planned breaking api changes in upstream msgpack, we wrap it the way we need it -
-to avoid having lots of clutter in the calling code. see tickets #968 and #3632.
+We wrap msgpack here the way we need it - to avoid having lots of clutter in the calling code.
 
 Packing
 -------
@@ -22,30 +21,27 @@ Packing
 
 Unpacking
 ---------
-- raw = True (the old way, used by borg <= 1.3)
-  This is currently still needed to not try to decode "raw" msgpack objects.
-  These could come either from str (new or old msgpack) or bytes (old msgpack).
-  Thus, we basically must know what we want and either keep the bytes we get
-  or decode them to str, if we want str.
-
-- raw = False (the new way)
-  This can be used in future, when we do not have to deal with data any more that was packed the old way.
+- raw = False (used by borg since borg 1.3)
+  We already can use this with borg 1.3 due to the want_bytes decoder.
+  This decoder can be removed in future, when we do not have to deal with data any more that was packed the old way.
   It will then unpack according to the msgpack 2.0 spec format and directly output bytes or str.
 
+- raw = True (the old way, used by borg < 1.3)
+
 - unicode_errors = 'surrogateescape' -> see description above (will be used when raw is False).
 
-As of borg 1.3, we have the first part on the way to fix the msgpack str/bytes mess, #968.
-borg now still needs to **read** old repos, archives, keys, ... so we can not yet fix it completely.
-But from now on, borg only **writes** new data according to the new msgpack spec,
-thus we can complete the fix for #968 in a later borg release.
+As of borg 1.3, we have fixed most of the msgpack str/bytes mess, #968.
+Borg now still needs to **read** old repos, archives, keys, ... so we can not yet fix it completely.
+But from now on, borg only **writes** new data according to the new msgpack 2.0 spec,
+thus we can remove some legacy support in a later borg release (some places are marked with "legacy").
 
 current way in msgpack terms
 ----------------------------
 
 - pack with use_bin_type=True (according to msgpack 2.0 spec)
 - packs str -> raw and bytes -> bin
-- unpack with raw=True (aka "the old way")
-- unpacks raw to bytes (thus we always need to decode manually if we want str)
+- unpack with raw=False (according to msgpack 2.0 spec, using unicode_errors='surrogateescape')
+- unpacks bin to bytes and raw to str (thus we need to re-encode manually if we want bytes from "raw")
 """
 
 from .datastruct import StableDict
@@ -66,8 +62,8 @@ from msgpack import OutOfData
 version = mp_version
 
 USE_BIN_TYPE = True
-RAW = True  # should become False later when we do not need to read old stuff any more
-UNICODE_ERRORS = 'surrogateescape'  # previously done by safe_encode, safe_decode
+RAW = False
+UNICODE_ERRORS = 'surrogateescape'
 
 
 class PackException(Exception):
@@ -161,7 +157,7 @@ def unpackb(packed, *, raw=RAW, unicode_errors=UNICODE_ERRORS,
 def unpack(stream, *, raw=RAW, unicode_errors=UNICODE_ERRORS,
            strict_map_key=False,
            **kwargs):
-    # assert raw == RAW
+    assert raw == RAW
     assert unicode_errors == UNICODE_ERRORS
     try:
         kw = dict(raw=raw, unicode_errors=unicode_errors,
diff --git a/src/borg/item.pyx b/src/borg/item.pyx
index 89f476c1a..4a6c81163 100644
--- a/src/borg/item.pyx
+++ b/src/borg/item.pyx
@@ -60,6 +60,15 @@ def fix_tuple_of_str_and_int(t):
     return t
 
 
+def want_bytes(v):
+    """we know that we want bytes and the value should be bytes"""
+    # legacy support: it being str can be caused by msgpack unpack decoding old data that was packed with use_bin_type=False
+    if isinstance(v, str):
+        v = v.encode('utf-8', errors='surrogateescape')
+    assert isinstance(v, bytes)
+    return v
+
+
 class PropDict:
     """
     Manage a dictionary via properties.
@@ -204,10 +213,10 @@ class Item(PropDict):
     user = PropDict._make_property('user', (str, type(None)), 'surrogate-escaped str or None')
     group = PropDict._make_property('group', (str, type(None)), 'surrogate-escaped str or None')
 
-    acl_access = PropDict._make_property('acl_access', bytes)
-    acl_default = PropDict._make_property('acl_default', bytes)
-    acl_extended = PropDict._make_property('acl_extended', bytes)
-    acl_nfs4 = PropDict._make_property('acl_nfs4', bytes)
+    acl_access = PropDict._make_property('acl_access', bytes, decode=want_bytes)
+    acl_default = PropDict._make_property('acl_default', bytes, decode=want_bytes)
+    acl_extended = PropDict._make_property('acl_extended', bytes, decode=want_bytes)
+    acl_nfs4 = PropDict._make_property('acl_nfs4', bytes, decode=want_bytes)
 
     mode = PropDict._make_property('mode', int)
     uid = PropDict._make_property('uid', int)
@@ -224,7 +233,7 @@ class Item(PropDict):
     # compatibility note: this is a new feature, in old archives size will be missing.
     size = PropDict._make_property('size', int)
 
-    hlid = PropDict._make_property('hlid', bytes)  # hard link id: same value means same hard link.
+    hlid = PropDict._make_property('hlid', bytes, decode=want_bytes)  # hard link id: same value means same hard link.
     hardlink_master = PropDict._make_property('hardlink_master', bool)  # legacy
 
     chunks = PropDict._make_property('chunks', (list, type(None)), 'list or None')
@@ -363,9 +372,9 @@ class EncryptedKey(PropDict):
     version = PropDict._make_property('version', int)
     algorithm = PropDict._make_property('algorithm', str)
     iterations = PropDict._make_property('iterations', int)
-    salt = PropDict._make_property('salt', bytes)
-    hash = PropDict._make_property('hash', bytes)
-    data = PropDict._make_property('data', bytes)
+    salt = PropDict._make_property('salt', bytes, decode=want_bytes)
+    hash = PropDict._make_property('hash', bytes, decode=want_bytes)
+    data = PropDict._make_property('data', bytes, decode=want_bytes)
     argon2_time_cost = PropDict._make_property('argon2_time_cost', int)
     argon2_memory_cost = PropDict._make_property('argon2_memory_cost', int)
     argon2_parallelism = PropDict._make_property('argon2_parallelism', int)
@@ -399,10 +408,10 @@ class Key(PropDict):
     __slots__ = ("_dict", )  # avoid setting attributes not supported by properties
 
     version = PropDict._make_property('version', int)
-    repository_id = PropDict._make_property('repository_id', bytes)
-    enc_key = PropDict._make_property('enc_key', bytes)
-    enc_hmac_key = PropDict._make_property('enc_hmac_key', bytes)
-    id_key = PropDict._make_property('id_key', bytes)
+    repository_id = PropDict._make_property('repository_id', bytes, decode=want_bytes)
+    enc_key = PropDict._make_property('enc_key', bytes, decode=want_bytes)
+    enc_hmac_key = PropDict._make_property('enc_hmac_key', bytes, decode=want_bytes)
+    id_key = PropDict._make_property('id_key', bytes, decode=want_bytes)
     chunk_seed = PropDict._make_property('chunk_seed', int)
     tam_required = PropDict._make_property('tam_required', bool)
 
@@ -443,7 +452,7 @@ class ArchiveItem(PropDict):
     chunker_params = PropDict._make_property('chunker_params', tuple)
     recreate_cmdline = PropDict._make_property('recreate_cmdline', list)  # list of s-e-str
     # recreate_source_id, recreate_args, recreate_partial_chunks were used in 1.1.0b1 .. b2
-    recreate_source_id = PropDict._make_property('recreate_source_id', bytes)
+    recreate_source_id = PropDict._make_property('recreate_source_id', bytes, decode=want_bytes)
     recreate_args = PropDict._make_property('recreate_args', list)  # list of s-e-str
     recreate_partial_chunks = PropDict._make_property('recreate_partial_chunks', list)  # list of tuples
     size = PropDict._make_property('size', int)
diff --git a/src/borg/remote.py b/src/borg/remote.py
index 8de302871..6ea51d3c3 100644
--- a/src/borg/remote.py
+++ b/src/borg/remote.py
@@ -38,8 +38,7 @@ logger = create_logger(__name__)
 
 RPC_PROTOCOL_VERSION = 2
 BORG_VERSION = parse_version(__version__)
-MSGID, MSG, ARGS, RESULT = 'i', 'm', 'a', 'r'  # pack
-MSGIDB, MSGB, ARGSB, RESULTB = b'i', b'm', b'a', b'r'  # unpack
+MSGID, MSG, ARGS, RESULT = 'i', 'm', 'a', 'r'
 
 MAX_INFLIGHT = 100
 
@@ -139,10 +138,6 @@ compatMap = {
 }
 
 
-def decode_keys(d):
-    return {k.decode(): d[k] for k in d}
-
-
 class RepositoryServer:  # pragma: no cover
     rpc_methods = (
         '__len__',
@@ -217,14 +212,13 @@ class RepositoryServer:  # pragma: no cover
                 for unpacked in unpacker:
                     if isinstance(unpacked, dict):
                         dictFormat = True
-                        msgid = unpacked[MSGIDB]
-                        method = unpacked[MSGB].decode()
-                        args = decode_keys(unpacked[ARGSB])
+                        msgid = unpacked[MSGID]
+                        method = unpacked[MSG]
+                        args = unpacked[ARGS]
                     elif isinstance(unpacked, tuple) and len(unpacked) == 4:
                         dictFormat = False
                         # The first field 'type' was always 1 and has always been ignored
                         _, msgid, method, args = unpacked
-                        method = method.decode()
                         args = self.positional_to_named(method, args)
                     else:
                         if self.repository is not None:
@@ -308,7 +302,7 @@ class RepositoryServer:  # pragma: no cover
         # clients since 1.1.0b3 use a dict as client_data
         # clients since 1.1.0b6 support json log format from server
         if isinstance(client_data, dict):
-            self.client_version = client_data[b'client_version']
+            self.client_version = client_data['client_version']
             level = logging.getLevelName(logging.getLogger('').level)
             setup_logging(is_serve=True, json=True, level=level)
             logger.debug('Initialized logging system for JSON-based protocol')
@@ -370,7 +364,6 @@ class RepositoryServer:  # pragma: no cover
         return self.repository.id
 
     def inject_exception(self, kind):
-        kind = kind.decode()
         s1 = 'test string'
         s2 = 'test string2'
         if kind == 'DoesNotExist':
@@ -484,35 +477,35 @@ class RemoteRepository:
 
     class RPCError(Exception):
         def __init__(self, unpacked):
-            # for borg < 1.1: unpacked only has b'exception_class' as key
-            # for borg 1.1+: unpacked has keys: b'exception_args', b'exception_full', b'exception_short', b'sysinfo'
+            # for borg < 1.1: unpacked only has 'exception_class' as key
+            # for borg 1.1+: unpacked has keys: 'exception_args', 'exception_full', 'exception_short', 'sysinfo'
             self.unpacked = unpacked
 
         def get_message(self):
-            if b'exception_short' in self.unpacked:
-                return b'\n'.join(self.unpacked[b'exception_short']).decode()
+            if 'exception_short' in self.unpacked:
+                return '\n'.join(self.unpacked['exception_short'])
             else:
                 return self.exception_class
 
         @property
         def traceback(self):
-            return self.unpacked.get(b'exception_trace', True)
+            return self.unpacked.get('exception_trace', True)
 
         @property
         def exception_class(self):
-            return self.unpacked[b'exception_class'].decode()
+            return self.unpacked['exception_class']
 
         @property
         def exception_full(self):
-            if b'exception_full' in self.unpacked:
-                return b'\n'.join(self.unpacked[b'exception_full']).decode()
+            if 'exception_full' in self.unpacked:
+                return '\n'.join(self.unpacked['exception_full'])
             else:
                 return self.get_message() + '\nRemote Exception (see remote log for the traceback)'
 
         @property
         def sysinfo(self):
-            if b'sysinfo' in self.unpacked:
-                return self.unpacked[b'sysinfo'].decode()
+            if 'sysinfo' in self.unpacked:
+                return self.unpacked['sysinfo']
             else:
                 return ''
 
@@ -577,9 +570,9 @@ class RemoteRepository:
                 raise ConnectionClosedWithHint('Is borg working on the server?') from None
             if version == RPC_PROTOCOL_VERSION:
                 self.dictFormat = False
-            elif isinstance(version, dict) and b'server_version' in version:
+            elif isinstance(version, dict) and 'server_version' in version:
                 self.dictFormat = True
-                self.server_version = version[b'server_version']
+                self.server_version = version['server_version']
             else:
                 raise Exception('Server insisted on using unsupported protocol version %s' % version)
 
@@ -734,9 +727,9 @@ This problem will go away as soon as the server has been upgraded to 1.0.7+.
             return msgid
 
         def handle_error(unpacked):
-            error = unpacked[b'exception_class'].decode()
-            old_server = b'exception_args' not in unpacked
-            args = unpacked.get(b'exception_args')
+            error = unpacked['exception_class']
+            old_server = 'exception_args' not in unpacked
+            args = unpacked.get('exception_args')
 
             if error == 'DoesNotExist':
                 raise Repository.DoesNotExist(self.location.processed)
@@ -748,29 +741,29 @@ This problem will go away as soon as the server has been upgraded to 1.0.7+.
                 if old_server:
                     raise IntegrityError('(not available)')
                 else:
-                    raise IntegrityError(args[0].decode())
+                    raise IntegrityError(args[0])
             elif error == 'AtticRepository':
                 if old_server:
                     raise Repository.AtticRepository('(not available)')
                 else:
-                    raise Repository.AtticRepository(args[0].decode())
+                    raise Repository.AtticRepository(args[0])
             elif error == 'PathNotAllowed':
                 if old_server:
                     raise PathNotAllowed('(unknown)')
                 else:
-                    raise PathNotAllowed(args[0].decode())
+                    raise PathNotAllowed(args[0])
             elif error == 'ParentPathDoesNotExist':
-                raise Repository.ParentPathDoesNotExist(args[0].decode())
+                raise Repository.ParentPathDoesNotExist(args[0])
             elif error == 'ObjectNotFound':
                 if old_server:
                     raise Repository.ObjectNotFound('(not available)', self.location.processed)
                 else:
-                    raise Repository.ObjectNotFound(args[0].decode(), self.location.processed)
+                    raise Repository.ObjectNotFound(args[0], self.location.processed)
             elif error == 'InvalidRPCMethod':
                 if old_server:
                     raise InvalidRPCMethod('(not available)')
                 else:
-                    raise InvalidRPCMethod(args[0].decode())
+                    raise InvalidRPCMethod(args[0])
             else:
                 raise self.RPCError(unpacked)
 
@@ -789,10 +782,10 @@ This problem will go away as soon as the server has been upgraded to 1.0.7+.
                 try:
                     unpacked = self.responses.pop(waiting_for[0])
                     waiting_for.pop(0)
-                    if b'exception_class' in unpacked:
+                    if 'exception_class' in unpacked:
                         handle_error(unpacked)
                     else:
-                        yield unpacked[RESULTB]
+                        yield unpacked[RESULT]
                         if not waiting_for and not calls:
                             return
                 except KeyError:
@@ -809,10 +802,10 @@ This problem will go away as soon as the server has been upgraded to 1.0.7+.
                         else:
                             return
                     else:
-                        if b'exception_class' in unpacked:
+                        if 'exception_class' in unpacked:
                             handle_error(unpacked)
                         else:
-                            yield unpacked[RESULTB]
+                            yield unpacked[RESULT]
             if self.to_send or ((calls or self.preload_ids) and len(waiting_for) < MAX_INFLIGHT):
                 w_fds = [self.stdin_fd]
             else:
@@ -829,26 +822,26 @@ This problem will go away as soon as the server has been upgraded to 1.0.7+.
                     self.unpacker.feed(data)
                     for unpacked in self.unpacker:
                         if isinstance(unpacked, dict):
-                            msgid = unpacked[MSGIDB]
+                            msgid = unpacked[MSGID]
                         elif isinstance(unpacked, tuple) and len(unpacked) == 4:
                             # The first field 'type' was always 1 and has always been ignored
                             _, msgid, error, res = unpacked
                             if error:
                                 # ignore res, because it is only a fixed string anyway.
-                                unpacked = {MSGIDB: msgid, b'exception_class': error}
+                                unpacked = {MSGID: msgid, 'exception_class': error}
                             else:
-                                unpacked = {MSGIDB: msgid, RESULTB: res}
+                                unpacked = {MSGID: msgid, RESULT: res}
                         else:
                             raise UnexpectedRPCDataFormatFromServer(data)
                         if msgid in self.ignore_responses:
                             self.ignore_responses.remove(msgid)
                             # async methods never return values, but may raise exceptions.
-                            if b'exception_class' in unpacked:
+                            if 'exception_class' in unpacked:
                                 self.async_responses[msgid] = unpacked
                             else:
                                 # we currently do not have async result values except "None",
                                 # so we do not add them into async_responses.
-                                if unpacked[RESULTB] is not None:
+                                if unpacked[RESULT] is not None:
                                     self.async_responses[msgid] = unpacked
                         else:
                             self.responses[msgid] = unpacked
diff --git a/src/borg/repository.py b/src/borg/repository.py
index 9267fe0e6..3fcc72aad 100644
--- a/src/borg/repository.py
+++ b/src/borg/repository.py
@@ -516,16 +516,16 @@ class Repository:
                 integrity = msgpack.unpack(fd)
         except FileNotFoundError:
             return
-        if integrity.get(b'version') != 2:
-            logger.warning('Unknown integrity data version %r in %s', integrity.get(b'version'), integrity_file)
+        if integrity.get('version') != 2:
+            logger.warning('Unknown integrity data version %r in %s', integrity.get('version'), integrity_file)
             return
-        return integrity[key].decode()
+        return integrity[key]
 
     def open_index(self, transaction_id, auto_recover=True):
         if transaction_id is None:
             return NSIndex()
         index_path = os.path.join(self.path, 'index.%d' % transaction_id)
-        integrity_data = self._read_integrity(transaction_id, b'index')
+        integrity_data = self._read_integrity(transaction_id, 'index')
         try:
             with IntegrityCheckedFile(index_path, write=False, integrity_data=integrity_data) as fd:
                 return NSIndex.read(fd)
@@ -575,7 +575,7 @@ class Repository:
                 self.io.cleanup(transaction_id)
             hints_path = os.path.join(self.path, 'hints.%d' % transaction_id)
             index_path = os.path.join(self.path, 'index.%d' % transaction_id)
-            integrity_data = self._read_integrity(transaction_id, b'hints')
+            integrity_data = self._read_integrity(transaction_id, 'hints')
             try:
                 with IntegrityCheckedFile(hints_path, write=False, integrity_data=integrity_data) as fd:
                     hints = msgpack.unpack(fd)
@@ -588,23 +588,23 @@ class Repository:
                 self.check_transaction()
                 self.prepare_txn(transaction_id)
                 return
-            if hints[b'version'] == 1:
+            if hints['version'] == 1:
                 logger.debug('Upgrading from v1 hints.%d', transaction_id)
-                self.segments = hints[b'segments']
+                self.segments = hints['segments']
                 self.compact = FreeSpace()
                 self.storage_quota_use = 0
                 self.shadow_index = {}
-                for segment in sorted(hints[b'compact']):
+                for segment in sorted(hints['compact']):
                     logger.debug('Rebuilding sparse info for segment %d', segment)
                     self._rebuild_sparse(segment)
                 logger.debug('Upgrade to v2 hints complete')
-            elif hints[b'version'] != 2:
-                raise ValueError('Unknown hints file version: %d' % hints[b'version'])
+            elif hints['version'] != 2:
+                raise ValueError('Unknown hints file version: %d' % hints['version'])
             else:
-                self.segments = hints[b'segments']
-                self.compact = FreeSpace(hints[b'compact'])
-                self.storage_quota_use = hints.get(b'storage_quota_use', 0)
-                self.shadow_index = hints.get(b'shadow_index', {})
+                self.segments = hints['segments']
+                self.compact = FreeSpace(hints['compact'])
+                self.storage_quota_use = hints.get('storage_quota_use', 0)
+                self.shadow_index = hints.get('shadow_index', {})
             self.log_storage_quota()
             # Drop uncommitted segments in the shadow index
             for key, shadowed_segments in self.shadow_index.items():
@@ -621,16 +621,16 @@ class Repository:
             os.rename(file + '.tmp', file)
 
         hints = {
-            b'version': 2,
-            b'segments': self.segments,
-            b'compact': self.compact,
-            b'storage_quota_use': self.storage_quota_use,
-            b'shadow_index': self.shadow_index,
+            'version': 2,
+            'segments': self.segments,
+            'compact': self.compact,
+            'storage_quota_use': self.storage_quota_use,
+            'shadow_index': self.shadow_index,
         }
         integrity = {
             # Integrity version started at 2, the current hints version.
             # Thus, integrity version == hints version, for now.
-            b'version': 2,
+            'version': 2,
         }
         transaction_id = self.io.get_segments_transaction_id()
         assert transaction_id is not None
@@ -647,7 +647,7 @@ class Repository:
         with IntegrityCheckedFile(hints_file + '.tmp', filename=hints_name, write=True) as fd:
             msgpack.pack(hints, fd)
             flush_and_sync(fd)
-        integrity[b'hints'] = fd.integrity_data
+        integrity['hints'] = fd.integrity_data
 
         # Write repository index
         index_name = 'index.%d' % transaction_id
@@ -656,7 +656,7 @@ class Repository:
             # XXX: Consider using SyncFile for index write-outs.
             self.index.write(fd)
             flush_and_sync(fd)
-        integrity[b'index'] = fd.integrity_data
+        integrity['index'] = fd.integrity_data
 
         # Write integrity file, containing checksums of the hints and index files
         integrity_name = 'integrity.%d' % transaction_id
diff --git a/src/borg/testsuite/archive.py b/src/borg/testsuite/archive.py
index 0eed9f7e8..9cdcf5046 100644
--- a/src/borg/testsuite/archive.py
+++ b/src/borg/testsuite/archive.py
@@ -171,7 +171,7 @@ class RobustUnpackerTestCase(BaseTestCase):
         return b''.join(msgpack.packb({'path': item}) for item in items)
 
     def _validator(self, value):
-        return isinstance(value, dict) and value.get(b'path') in (b'foo', b'bar', b'boo', b'baz')
+        return isinstance(value, dict) and value.get('path') in ('foo', 'bar', 'boo', 'baz')
 
     def process(self, input):
         unpacker = RobustUnpacker(validator=self._validator, item_keys=ITEM_KEYS)
@@ -190,10 +190,10 @@ class RobustUnpackerTestCase(BaseTestCase):
                   (False, [b'garbage'] + [self.make_chunks(['boo', 'baz'])])]
         result = self.process(chunks)
         self.assert_equal(result, [
-            {b'path': b'foo'}, {b'path': b'bar'},
+            {'path': 'foo'}, {'path': 'bar'},
             103, 97, 114, 98, 97, 103, 101,
-            {b'path': b'boo'},
-            {b'path': b'baz'}])
+            {'path': 'boo'},
+            {'path': 'baz'}])
 
     def split(self, left, length):
         parts = []
@@ -206,19 +206,19 @@ class RobustUnpackerTestCase(BaseTestCase):
         chunks = self.split(self.make_chunks(['foo', 'bar', 'boo', 'baz']), 2)
         input = [(False, chunks)]
         result = self.process(input)
-        self.assert_equal(result, [{b'path': b'foo'}, {b'path': b'bar'}, {b'path': b'boo'}, {b'path': b'baz'}])
+        self.assert_equal(result, [{'path': 'foo'}, {'path': 'bar'}, {'path': 'boo'}, {'path': 'baz'}])
 
     def test_missing_chunk(self):
         chunks = self.split(self.make_chunks(['foo', 'bar', 'boo', 'baz']), 4)
         input = [(False, chunks[:3]), (True, chunks[4:])]
         result = self.process(input)
-        self.assert_equal(result, [{b'path': b'foo'}, {b'path': b'boo'}, {b'path': b'baz'}])
+        self.assert_equal(result, [{'path': 'foo'}, {'path': 'boo'}, {'path': 'baz'}])
 
     def test_corrupt_chunk(self):
         chunks = self.split(self.make_chunks(['foo', 'bar', 'boo', 'baz']), 4)
         input = [(False, chunks[:3]), (True, [b'gar', b'bage'] + chunks[3:])]
         result = self.process(input)
-        self.assert_equal(result, [{b'path': b'foo'}, {b'path': b'boo'}, {b'path': b'baz'}])
+        self.assert_equal(result, [{'path': 'foo'}, {'path': 'boo'}, {'path': 'baz'}])
 
 
 @pytest.fixture
diff --git a/src/borg/testsuite/archiver.py b/src/borg/testsuite/archiver.py
index f3315b676..a4205ea76 100644
--- a/src/borg/testsuite/archiver.py
+++ b/src/borg/testsuite/archiver.py
@@ -3623,14 +3623,14 @@ id: 2 / e29442 3506da 4e1ea7 / 25f62a 5a3d41 - 02
         self.cmd('init', '--encryption=repokey', self.repository_location)
         with Repository(self.repository_path) as repository:
             key = msgpack.unpackb(a2b_base64(repository.load_key()))
-        assert key[b'algorithm'] == b'argon2 chacha20-poly1305'
+        assert key['algorithm'] == 'argon2 chacha20-poly1305'
 
     def test_init_with_explicit_key_algorithm(self):
         """https://github.com/borgbackup/borg/issues/747#issuecomment-1076160401"""
         self.cmd('init', '--encryption=repokey', '--key-algorithm=pbkdf2', self.repository_location)
         with Repository(self.repository_path) as repository:
             key = msgpack.unpackb(a2b_base64(repository.load_key()))
-        assert key[b'algorithm'] == b'sha256'
+        assert key['algorithm'] == 'sha256'
 
     def verify_change_passphrase_does_not_change_algorithm(self, given_algorithm, expected_algorithm):
         self.cmd('init', '--encryption=repokey', '--key-algorithm', given_algorithm, self.repository_location)
@@ -3640,7 +3640,7 @@ id: 2 / e29442 3506da 4e1ea7 / 25f62a 5a3d41 - 02
 
         with Repository(self.repository_path) as repository:
             key = msgpack.unpackb(a2b_base64(repository.load_key()))
-            assert key[b'algorithm'] == expected_algorithm.encode()
+            assert key['algorithm'] == expected_algorithm
 
     def test_change_passphrase_does_not_change_algorithm_argon2(self):
         self.verify_change_passphrase_does_not_change_algorithm('argon2', 'argon2 chacha20-poly1305')
@@ -3655,7 +3655,7 @@ id: 2 / e29442 3506da 4e1ea7 / 25f62a 5a3d41 - 02
 
         with Repository(self.repository_path) as repository:
             key = msgpack.unpackb(a2b_base64(repository.load_key()))
-            assert key[b'algorithm'] == expected_algorithm.encode()
+            assert key['algorithm'] == expected_algorithm
 
     def test_change_location_does_not_change_algorithm_argon2(self):
         self.verify_change_location_does_not_change_algorithm('argon2', 'argon2 chacha20-poly1305')
@@ -3969,7 +3969,7 @@ class ManifestAuthenticationTest(ArchiverTestCaseBase):
             key.change_passphrase(key._passphrase)
 
             manifest = msgpack.unpackb(key.decrypt(Manifest.MANIFEST_ID, repository.get(Manifest.MANIFEST_ID)))
-            del manifest[b'tam']
+            del manifest['tam']
             repository.put(Manifest.MANIFEST_ID, key.encrypt(Manifest.MANIFEST_ID, msgpack.packb(manifest)))
             repository.commit(compact=False)
         output = self.cmd('list', '--debug', self.repository_location)
diff --git a/src/borg/testsuite/key.py b/src/borg/testsuite/key.py
index 5073c5b23..02eaa86e5 100644
--- a/src/borg/testsuite/key.py
+++ b/src/borg/testsuite/key.py
@@ -360,23 +360,23 @@ class TestTAM:
         assert blob.startswith(b'\x82')
 
         unpacked = msgpack.unpackb(blob)
-        assert unpacked[b'tam'][b'type'] == b'HKDF_HMAC_SHA512'
+        assert unpacked['tam']['type'] == 'HKDF_HMAC_SHA512'
 
         unpacked, verified = key.unpack_and_verify_manifest(blob)
         assert verified
-        assert unpacked[b'foo'] == b'bar'
-        assert b'tam' not in unpacked
+        assert unpacked['foo'] == 'bar'
+        assert 'tam' not in unpacked
 
-    @pytest.mark.parametrize('which', (b'hmac', b'salt'))
+    @pytest.mark.parametrize('which', ('hmac', 'salt'))
     def test_tampered(self, key, which):
         data = {'foo': 'bar'}
         blob = key.pack_and_authenticate_metadata(data)
         assert blob.startswith(b'\x82')
 
         unpacked = msgpack.unpackb(blob, object_hook=StableDict)
-        assert len(unpacked[b'tam'][which]) == 64
-        unpacked[b'tam'][which] = unpacked[b'tam'][which][0:32] + bytes(32)
-        assert len(unpacked[b'tam'][which]) == 64
+        assert len(unpacked['tam'][which]) == 64
+        unpacked['tam'][which] = unpacked['tam'][which][0:32] + bytes(32)
+        assert len(unpacked['tam'][which]) == 64
         blob = msgpack.packb(unpacked)
 
         with pytest.raises(TAMInvalid):
@@ -421,4 +421,4 @@ def test_key_file_roundtrip(monkeypatch, cli_argument, expected_algorithm):
     load_me = RepoKey.detect(repository, manifest_data=None)
 
     assert to_dict(load_me) == to_dict(save_me)
-    assert msgpack.unpackb(a2b_base64(saved))[b'algorithm'] == expected_algorithm.encode()
+    assert msgpack.unpackb(a2b_base64(saved))['algorithm'] == expected_algorithm
diff --git a/src/borg/testsuite/repository.py b/src/borg/testsuite/repository.py
index b4944e58a..52f03e668 100644
--- a/src/borg/testsuite/repository.py
+++ b/src/borg/testsuite/repository.py
@@ -655,8 +655,8 @@ class RepositoryAuxiliaryCorruptionTestCase(RepositoryTestCaseBase):
             hints = msgpack.unpack(fd)
             fd.seek(0)
             # Corrupt segment refcount
-            assert hints[b'segments'][2] == 1
-            hints[b'segments'][2] = 0
+            assert hints['segments'][2] == 1
+            hints['segments'][2] = 0
             msgpack.pack(hints, fd)
             fd.truncate()
 

From 33444be9268d70f163b16f1bf8c7a5bf0f1fb353 Mon Sep 17 00:00:00 2001
From: Thomas Waldmann <tw@waldmann-edv.de>
Date: Thu, 19 May 2022 23:12:21 +0200
Subject: [PATCH 017/160] more str vs bytes fixing

---
 src/borg/crypto/key.py |  6 ++-
 src/borg/helpers/fs.py |  4 +-
 src/borg/item.pyx      | 88 ++++++++++++++++++++++++++++++------------
 3 files changed, 70 insertions(+), 28 deletions(-)

diff --git a/src/borg/crypto/key.py b/src/borg/crypto/key.py
index 15df53d00..2b7b50da8 100644
--- a/src/borg/crypto/key.py
+++ b/src/borg/crypto/key.py
@@ -22,7 +22,7 @@ from ..helpers import bin_to_hex
 from ..helpers.passphrase import Passphrase, PasswordRetriesExceeded, PassphraseWrong
 from ..helpers import msgpack
 from ..helpers.manifest import Manifest
-from ..item import Key, EncryptedKey
+from ..item import Key, EncryptedKey, want_bytes
 from ..platform import SaveFile
 
 from .nonces import NonceManager
@@ -250,8 +250,10 @@ class KeyBase:
                 return unpacked, False
         tam_hmac = tam.get('hmac')
         tam_salt = tam.get('salt')
-        if not isinstance(tam_salt, bytes) or not isinstance(tam_hmac, bytes):
+        if not isinstance(tam_salt, (bytes, str)) or not isinstance(tam_hmac, (bytes, str)):
             raise TAMInvalid()
+        tam_hmac = want_bytes(tam_hmac)  # legacy
+        tam_salt = want_bytes(tam_salt)  # legacy
         offset = data.index(tam_hmac)
         data[offset:offset + 64] = bytes(64)
         tam_key = self._tam_key(tam_salt, context=b'manifest')
diff --git a/src/borg/helpers/fs.py b/src/borg/helpers/fs.py
index fecda9c69..5509e0d0f 100644
--- a/src/borg/helpers/fs.py
+++ b/src/borg/helpers/fs.py
@@ -205,8 +205,8 @@ class HardLinkManager:
 
     def hardlink_id_from_path(self, path):
         """compute a hardlink id from a path"""
-        assert isinstance(path, bytes)
-        return hashlib.sha256(path).digest()
+        assert isinstance(path, str)
+        return hashlib.sha256(path.encode('utf-8', errors='surrogateescape')).digest()
 
     def hardlink_id_from_inode(self, *, ino, dev):
         """compute a hardlink id from an inode"""
diff --git a/src/borg/item.pyx b/src/borg/item.pyx
index 4a6c81163..9fddfa457 100644
--- a/src/borg/item.pyx
+++ b/src/borg/item.pyx
@@ -15,11 +15,11 @@ cdef extern from "_item.c":
 API_VERSION = '1.2_01'
 
 
-def fix_key(data, key):
+def fix_key(data, key, *, errors='strict'):
     """if k is a bytes-typed key, migrate key/value to a str-typed key in dict data"""
     if isinstance(key, bytes):
         value = data.pop(key)
-        key = key.decode()
+        key = key.decode('utf-8', errors=errors)
         data[key] = value
     assert isinstance(key, str)
     return key
@@ -29,46 +29,77 @@ def fix_str_value(data, key, errors='surrogateescape'):
     """makes sure that data[key] is a str (decode if it is bytes)"""
     assert isinstance(key, str)  # fix_key must be called first
     value = data[key]
-    if isinstance(value, bytes):
-        value = value.decode('utf-8', errors=errors)
-        data[key] = value
-    assert isinstance(value, str)
+    value = want_str(value, errors=errors)
+    data[key] = value
     return value
 
 
-def fix_list_of_str(t):
+def fix_bytes_value(data, key):
+    """makes sure that data[key] is bytes (encode if it is str)"""
+    assert isinstance(key, str)  # fix_key must be called first
+    value = data[key]
+    value = want_bytes(value)
+    data[key] = value
+    return value
+
+
+def fix_list_of_str(v):
     """make sure we have a list of str"""
-    assert isinstance(t, (tuple, list))
-    l = [e.decode() if isinstance(e, bytes) else e for e in t]
-    assert all(isinstance(e, str) for e in l), repr(l)
-    return l
+    assert isinstance(v, (tuple, list))
+    return [want_str(e) for e in v]
 
 
-def fix_tuple_of_str(t):
+def fix_list_of_bytes(v):
+    """make sure we have a list of bytes"""
+    assert isinstance(v, (tuple, list))
+    return [want_bytes(e) for e in v]
+
+
+def fix_list_of_chunkentries(v):
+    """make sure we have a list of correct chunkentries"""
+    assert isinstance(v, (tuple, list))
+    chunks = []
+    for ce in v:
+        assert isinstance(ce, (tuple, list))
+        assert len(ce) == 3  # id, size, csize
+        assert isinstance(ce[1], int)
+        assert isinstance(ce[2], int)
+        ce_fixed = [want_bytes(ce[0]), ce[1], ce[2]]  # list!
+        chunks.append(ce_fixed)  # create a list of lists
+    return chunks
+
+
+def fix_tuple_of_str(v):
     """make sure we have a tuple of str"""
-    assert isinstance(t, (tuple, list))
-    t = tuple(e.decode() if isinstance(e, bytes) else e for e in t)
-    assert all(isinstance(e, str) for e in t), repr(t)
-    return t
+    assert isinstance(v, (tuple, list))
+    return tuple(want_str(e) for e in v)
 
 
-def fix_tuple_of_str_and_int(t):
+def fix_tuple_of_str_and_int(v):
     """make sure we have a tuple of str"""
-    assert isinstance(t, (tuple, list))
-    t = tuple(e.decode() if isinstance(e, bytes) else e for e in t)
+    assert isinstance(v, (tuple, list))
+    t = tuple(e.decode() if isinstance(e, bytes) else e for e in v)
     assert all(isinstance(e, (str, int)) for e in t), repr(t)
     return t
 
 
-def want_bytes(v):
+def want_bytes(v, *, errors='surrogateescape'):
     """we know that we want bytes and the value should be bytes"""
     # legacy support: it being str can be caused by msgpack unpack decoding old data that was packed with use_bin_type=False
     if isinstance(v, str):
-        v = v.encode('utf-8', errors='surrogateescape')
+        v = v.encode('utf-8', errors=errors)
     assert isinstance(v, bytes)
     return v
 
 
+def want_str(v, *, errors='surrogateescape'):
+    """we know that we want str and the value should be str"""
+    if isinstance(v, bytes):
+        v = v.decode('utf-8', errors=errors)
+    assert isinstance(v, str)
+    return v
+
+
 class PropDict:
     """
     Manage a dictionary via properties.
@@ -349,6 +380,11 @@ class Item(PropDict):
             k = fix_key(d, k)
             if k in ('path', 'source', 'user', 'group'):
                 v = fix_str_value(d, k)
+            if k in ('chunks', 'chunks_healthy'):
+                v = fix_list_of_chunkentries(v)
+            if k in ('acl_access', 'acl_default', 'acl_extended', 'acl_nfs4'):
+                v = fix_bytes_value(d, k)
+            # TODO: xattrs
             self._dict[k] = v
 
 
@@ -476,6 +512,8 @@ class ArchiveItem(PropDict):
                 v = fix_tuple_of_str_and_int(v)
             if k in ('cmdline', 'recreate_cmdline'):
                 v = fix_list_of_str(v)
+            if k == 'items':
+                v = fix_list_of_bytes(v)
             self._dict[k] = v
 
 
@@ -511,13 +549,15 @@ class ManifestItem(PropDict):
                 ad = v
                 assert isinstance(ad, dict)
                 for ak, av in list(ad.items()):
-                    ak = fix_key(ad, ak)
+                    ak = fix_key(ad, ak, errors='surrogateescape')
                     assert isinstance(av, dict)
                     for ik, iv in list(av.items()):
                         ik = fix_key(av, ik)
+                        if ik == 'id':
+                            fix_bytes_value(av, 'id')
+                        if ik == 'time':
+                            fix_str_value(av, 'time')
                     assert set(av) == {'id', 'time'}
-                    assert isinstance(av['id'], bytes)
-                    fix_str_value(av, 'time')
             if k == 'timestamp':
                 v = fix_str_value(d, k, 'replace')
             if k == 'config':

From 655c1b9cc2ed9927d52bc6338d2debeb24c69786 Mon Sep 17 00:00:00 2001
From: Thomas Waldmann <tw@waldmann-edv.de>
Date: Sat, 28 May 2022 21:57:22 +0200
Subject: [PATCH 018/160] update docstrings / comments

---
 src/borg/item.pyx | 20 +++++++-------------
 1 file changed, 7 insertions(+), 13 deletions(-)

diff --git a/src/borg/item.pyx b/src/borg/item.pyx
index 9fddfa457..c44ce5428 100644
--- a/src/borg/item.pyx
+++ b/src/borg/item.pyx
@@ -223,14 +223,9 @@ class Item(PropDict):
     Items are created either from msgpack unpacker output, from another dict, from kwargs or
     built step-by-step by setting attributes.
 
-    msgpack gives us a dict with bytes-typed keys, just give it to Item(internal_dict=d) and use item.key_name later.
-    msgpack gives us byte-typed values for stuff that should be str, we automatically decode when getting
-    such a property and encode when setting it.
+    msgpack unpacker gives us a dict, just give it to Item(internal_dict=d) and use item.key_name later.
 
     If an Item shall be serialized, give as_dict() method output to msgpack packer.
-
-    A bug in Attic up to and including release 0.13 added a (meaningless) 'acl' key to every item.
-    We must never re-use this key. See test_attic013_acl_bug for details.
     """
 
     VALID_KEYS = ITEM_KEYS | {'deleted', 'nlink', }  # str-typed keys
@@ -261,7 +256,6 @@ class Item(PropDict):
     birthtime = PropDict._make_property('birthtime', int, 'int (ns)', encode=int_to_timestamp, decode=timestamp_to_int)
 
     # size is only present for items with a chunk list and then it is sum(chunk_sizes)
-    # compatibility note: this is a new feature, in old archives size will be missing.
     size = PropDict._make_property('size', int)
 
     hlid = PropDict._make_property('hlid', bytes, decode=want_bytes)  # hard link id: same value means same hard link.
@@ -395,13 +389,13 @@ class EncryptedKey(PropDict):
     A EncryptedKey is created either from msgpack unpacker output, from another dict, from kwargs or
     built step-by-step by setting attributes.
 
-    msgpack gives us a dict with bytes-typed keys, just give it to EncryptedKey(d) and use enc_key.xxx later.
+    msgpack unpacker gives us a dict, just give it to EncryptedKey(d) and use enc_key.xxx later.
 
     If a EncryptedKey shall be serialized, give as_dict() method output to msgpack packer.
     """
 
-    VALID_KEYS = { 'version', 'algorithm', 'iterations', 'salt', 'hash', 'data',
-                   'argon2_time_cost', 'argon2_memory_cost', 'argon2_parallelism', 'argon2_type' }
+    VALID_KEYS = {'version', 'algorithm', 'iterations', 'salt', 'hash', 'data',
+                  'argon2_time_cost', 'argon2_memory_cost', 'argon2_parallelism', 'argon2_type'}
 
     __slots__ = ("_dict", )  # avoid setting attributes not supported by properties
 
@@ -434,7 +428,7 @@ class Key(PropDict):
     A Key is created either from msgpack unpacker output, from another dict, from kwargs or
     built step-by-step by setting attributes.
 
-    msgpack gives us a dict with bytes-typed keys, just give it to Key(d) and use key.xxx later.
+    msgpack unpacker gives us a dict, just give it to Key(d) and use key.xxx later.
 
     If a Key shall be serialized, give as_dict() method output to msgpack packer.
     """
@@ -467,7 +461,7 @@ class ArchiveItem(PropDict):
     An ArchiveItem is created either from msgpack unpacker output, from another dict, from kwargs or
     built step-by-step by setting attributes.
 
-    msgpack gives us a dict with bytes-typed keys, just give it to ArchiveItem(d) and use arch.xxx later.
+    msgpack unpacker gives us a dict, just give it to ArchiveItem(d) and use arch.xxx later.
 
     If a ArchiveItem shall be serialized, give as_dict() method output to msgpack packer.
     """
@@ -524,7 +518,7 @@ class ManifestItem(PropDict):
     A ManifestItem is created either from msgpack unpacker output, from another dict, from kwargs or
     built step-by-step by setting attributes.
 
-    msgpack gives us a dict with bytes-typed keys, just give it to ManifestItem(d) and use manifest.xxx later.
+    msgpack unpacker gives us a dict, just give it to ManifestItem(d) and use manifest.xxx later.
 
     If a ManifestItem shall be serialized, give as_dict() method output to msgpack packer.
     """

From 8e58525fc6d3eceae4d846a7be9e2eed20084580 Mon Sep 17 00:00:00 2001
From: Thomas Waldmann <tw@waldmann-edv.de>
Date: Sun, 29 May 2022 15:38:43 +0200
Subject: [PATCH 019/160] Item: remove some decode= params

update_internal() makes sure they have the desired type already.
---
 src/borg/item.pyx | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/src/borg/item.pyx b/src/borg/item.pyx
index c44ce5428..0fabc0241 100644
--- a/src/borg/item.pyx
+++ b/src/borg/item.pyx
@@ -239,10 +239,10 @@ class Item(PropDict):
     user = PropDict._make_property('user', (str, type(None)), 'surrogate-escaped str or None')
     group = PropDict._make_property('group', (str, type(None)), 'surrogate-escaped str or None')
 
-    acl_access = PropDict._make_property('acl_access', bytes, decode=want_bytes)
-    acl_default = PropDict._make_property('acl_default', bytes, decode=want_bytes)
-    acl_extended = PropDict._make_property('acl_extended', bytes, decode=want_bytes)
-    acl_nfs4 = PropDict._make_property('acl_nfs4', bytes, decode=want_bytes)
+    acl_access = PropDict._make_property('acl_access', bytes)
+    acl_default = PropDict._make_property('acl_default', bytes)
+    acl_extended = PropDict._make_property('acl_extended', bytes)
+    acl_nfs4 = PropDict._make_property('acl_nfs4', bytes)
 
     mode = PropDict._make_property('mode', int)
     uid = PropDict._make_property('uid', int)
@@ -258,7 +258,7 @@ class Item(PropDict):
     # size is only present for items with a chunk list and then it is sum(chunk_sizes)
     size = PropDict._make_property('size', int)
 
-    hlid = PropDict._make_property('hlid', bytes, decode=want_bytes)  # hard link id: same value means same hard link.
+    hlid = PropDict._make_property('hlid', bytes)  # hard link id: same value means same hard link.
     hardlink_master = PropDict._make_property('hardlink_master', bool)  # legacy
 
     chunks = PropDict._make_property('chunks', (list, type(None)), 'list or None')
@@ -482,7 +482,7 @@ class ArchiveItem(PropDict):
     chunker_params = PropDict._make_property('chunker_params', tuple)
     recreate_cmdline = PropDict._make_property('recreate_cmdline', list)  # list of s-e-str
     # recreate_source_id, recreate_args, recreate_partial_chunks were used in 1.1.0b1 .. b2
-    recreate_source_id = PropDict._make_property('recreate_source_id', bytes, decode=want_bytes)
+    recreate_source_id = PropDict._make_property('recreate_source_id', bytes)
     recreate_args = PropDict._make_property('recreate_args', list)  # list of s-e-str
     recreate_partial_chunks = PropDict._make_property('recreate_partial_chunks', list)  # list of tuples
     size = PropDict._make_property('size', int)

From 7b138cc7107ebc00f5b9ed422e2794da8eedba61 Mon Sep 17 00:00:00 2001
From: Thomas Waldmann <tw@waldmann-edv.de>
Date: Sun, 29 May 2022 16:43:51 +0200
Subject: [PATCH 020/160] Item: convert timestamps once, get rid of bigint code

---
 src/borg/archiver.py          |  4 ----
 src/borg/helpers/__init__.py  |  2 +-
 src/borg/helpers/msgpack.py   | 25 +++----------------------
 src/borg/item.pyx             | 18 ++++++++++++++++--
 src/borg/testsuite/helpers.py | 14 +-------------
 5 files changed, 21 insertions(+), 42 deletions(-)

diff --git a/src/borg/archiver.py b/src/borg/archiver.py
index a91e43c54..7ac3c7e6d 100644
--- a/src/borg/archiver.py
+++ b/src/borg/archiver.py
@@ -366,10 +366,6 @@ class Archiver:
                 if chunks_healthy is not None:
                     item._dict['chunks_healthy'] = chunks
                 item._dict.pop('source')  # not used for hardlinks any more, replaced by hlid
-            for attr in 'atime', 'ctime', 'mtime', 'birthtime':
-                if attr in item:
-                    ns = getattr(item, attr)  # decode (bigint or Timestamp) --> int ns
-                    setattr(item, attr, ns)  # encode int ns --> msgpack.Timestamp only, no bigint any more
             # make sure we only have desired stuff in the new item. specifically, make sure to get rid of:
             # - 'acl' remnants of bug in attic <= 0.13
             # - 'hardlink_master' (superseded by hlid)
diff --git a/src/borg/helpers/__init__.py b/src/borg/helpers/__init__.py
index 34a59b903..d8a4cda62 100644
--- a/src/borg/helpers/__init__.py
+++ b/src/borg/helpers/__init__.py
@@ -18,7 +18,7 @@ from .progress import *  # NOQA
 from .time import *  # NOQA
 from .yes import *  # NOQA
 
-from .msgpack import is_slow_msgpack, is_supported_msgpack, int_to_bigint, bigint_to_int, get_limited_unpacker
+from .msgpack import is_slow_msgpack, is_supported_msgpack, get_limited_unpacker
 from . import msgpack
 
 # generic mechanism to enable users to invoke workarounds by setting the
diff --git a/src/borg/helpers/msgpack.py b/src/borg/helpers/msgpack.py
index 268ee30e7..4e79c0274 100644
--- a/src/borg/helpers/msgpack.py
+++ b/src/borg/helpers/msgpack.py
@@ -201,30 +201,11 @@ def get_limited_unpacker(kind):
     return Unpacker(**args)
 
 
-def bigint_to_int(mtime):  # legacy
-    """Convert bytearray to int
-    """
-    if isinstance(mtime, bytes):
-        return int.from_bytes(mtime, 'little', signed=True)
-    return mtime
-
-
-def int_to_bigint(value):  # legacy
-    """Convert integers larger than 64 bits to bytearray
-
-    Smaller integers are left alone
-    """
-    if value.bit_length() > 63:
-        return value.to_bytes((value.bit_length() + 9) // 8, 'little', signed=True)
-    return value
-
-
 def int_to_timestamp(ns):
+    assert isinstance(ns, int)
     return Timestamp.from_unix_nano(ns)
 
 
 def timestamp_to_int(ts):
-    if isinstance(ts, Timestamp):
-        return ts.to_unix_nano()
-    # legacy support note: we need to keep the bigint conversion for compatibility with borg < 1.3 archives.
-    return bigint_to_int(ts)
+    assert isinstance(ts, Timestamp)
+    return ts.to_unix_nano()
diff --git a/src/borg/item.pyx b/src/borg/item.pyx
index 0fabc0241..1520527a3 100644
--- a/src/borg/item.pyx
+++ b/src/borg/item.pyx
@@ -4,7 +4,7 @@ from collections import namedtuple
 from .constants import ITEM_KEYS, ARCHIVE_KEYS
 from .helpers import StableDict
 from .helpers import format_file_size
-from .helpers.msgpack import timestamp_to_int, int_to_timestamp
+from .helpers.msgpack import timestamp_to_int, int_to_timestamp, Timestamp
 
 
 cdef extern from "_item.c":
@@ -83,6 +83,17 @@ def fix_tuple_of_str_and_int(v):
     return t
 
 
+def fix_timestamp(v):
+    """make sure v is a Timestamp"""
+    if isinstance(v, Timestamp):
+        return v
+    # legacy support
+    if isinstance(v, bytes):  # was: bigint_to_int()
+        v = int.from_bytes(v, 'little', signed=True)
+    assert isinstance(v, int)
+    return int_to_timestamp(v)
+
+
 def want_bytes(v, *, errors='surrogateescape'):
     """we know that we want bytes and the value should be bytes"""
     # legacy support: it being str can be caused by msgpack unpack decoding old data that was packed with use_bin_type=False
@@ -369,13 +380,16 @@ class Item(PropDict):
             return False
 
     def update_internal(self, d):
-        # legacy support for migration (data from old msgpacks comes in as bytes always, but sometimes we want str)
+        # legacy support for migration (data from old msgpacks comes in as bytes always, but sometimes we want str),
+        # also need to fix old timestamp data types.
         for k, v in list(d.items()):
             k = fix_key(d, k)
             if k in ('path', 'source', 'user', 'group'):
                 v = fix_str_value(d, k)
             if k in ('chunks', 'chunks_healthy'):
                 v = fix_list_of_chunkentries(v)
+            if k in ('atime', 'ctime', 'mtime', 'birthtime'):
+                v = fix_timestamp(v)
             if k in ('acl_access', 'acl_default', 'acl_extended', 'acl_nfs4'):
                 v = fix_bytes_value(d, k)
             # TODO: xattrs
diff --git a/src/borg/testsuite/helpers.py b/src/borg/testsuite/helpers.py
index b181da564..fd0414116 100644
--- a/src/borg/testsuite/helpers.py
+++ b/src/borg/testsuite/helpers.py
@@ -22,7 +22,7 @@ from ..helpers import get_base_dir, get_cache_dir, get_keys_dir, get_security_di
 from ..helpers import is_slow_msgpack
 from ..helpers import msgpack
 from ..helpers import yes, TRUISH, FALSISH, DEFAULTISH
-from ..helpers import StableDict, int_to_bigint, bigint_to_int, bin_to_hex
+from ..helpers import StableDict, bin_to_hex
 from ..helpers import parse_timestamp, ChunkIteratorFileWrapper, ChunkerParams
 from ..helpers import ProgressIndicatorPercent, ProgressIndicatorEndless
 from ..helpers import swidth_slice
@@ -38,18 +38,6 @@ from ..helpers.passphrase import Passphrase, PasswordRetriesExceeded
 from . import BaseTestCase, FakeInputs
 
 
-class BigIntTestCase(BaseTestCase):
-
-    def test_bigint(self):
-        self.assert_equal(int_to_bigint(0), 0)
-        self.assert_equal(int_to_bigint(2**63-1), 2**63-1)
-        self.assert_equal(int_to_bigint(-2**63+1), -2**63+1)
-        self.assert_equal(int_to_bigint(2**63), b'\x00\x00\x00\x00\x00\x00\x00\x80\x00')
-        self.assert_equal(int_to_bigint(-2**63), b'\x00\x00\x00\x00\x00\x00\x00\x80\xff')
-        self.assert_equal(bigint_to_int(int_to_bigint(-2**70)), -2**70)
-        self.assert_equal(bigint_to_int(int_to_bigint(2**70)), 2**70)
-
-
 def test_bin_to_hex():
     assert bin_to_hex(b'') == ''
     assert bin_to_hex(b'\x00\x01\xff') == '0001ff'

From 9d684120a2ae91fcd75003cda1ce36e7c1f22056 Mon Sep 17 00:00:00 2001
From: Thomas Waldmann <tw@waldmann-edv.de>
Date: Sun, 29 May 2022 17:32:42 +0200
Subject: [PATCH 021/160] Item: assert type also in property getter

also: fixed Item.xattrs to be StableDict (not just a dict, as the
msgpack unpacker gives us)
---
 src/borg/item.pyx | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/src/borg/item.pyx b/src/borg/item.pyx
index 1520527a3..0e8ff179e 100644
--- a/src/borg/item.pyx
+++ b/src/borg/item.pyx
@@ -207,6 +207,8 @@ class PropDict:
                 raise AttributeError(attr_error_msg) from None
             if decode is not None:
                 value = decode(value)
+            if not isinstance(value, value_type):
+                raise TypeError(type_error_msg)
             return value
 
         def _set(self, value):
@@ -392,7 +394,10 @@ class Item(PropDict):
                 v = fix_timestamp(v)
             if k in ('acl_access', 'acl_default', 'acl_extended', 'acl_nfs4'):
                 v = fix_bytes_value(d, k)
-            # TODO: xattrs
+            if k == 'xattrs':
+                if not isinstance(v, StableDict):
+                    v = StableDict(v)
+                # TODO: xattrs key/value types
             self._dict[k] = v
 
 

From 64cc16a9f470925dc0c9da152ec3ff2864b3ae95 Mon Sep 17 00:00:00 2001
From: Thomas Waldmann <tw@waldmann-edv.de>
Date: Sun, 29 May 2022 21:22:50 +0200
Subject: [PATCH 022/160] Item: fix xattr processing

Item.xattrs is now always a StableDict mapping bytes keys -> bytes values.

The special casing of empty values (b'') getting replaced by None was removed.
---
 src/borg/item.pyx | 12 +++++++++---
 src/borg/xattr.py |  8 ++------
 2 files changed, 11 insertions(+), 9 deletions(-)

diff --git a/src/borg/item.pyx b/src/borg/item.pyx
index 0e8ff179e..c3f59ed27 100644
--- a/src/borg/item.pyx
+++ b/src/borg/item.pyx
@@ -99,7 +99,7 @@ def want_bytes(v, *, errors='surrogateescape'):
     # legacy support: it being str can be caused by msgpack unpack decoding old data that was packed with use_bin_type=False
     if isinstance(v, str):
         v = v.encode('utf-8', errors=errors)
-    assert isinstance(v, bytes)
+    assert isinstance(v, bytes), f'not a bytes object, but {v!r}'
     return v
 
 
@@ -107,7 +107,7 @@ def want_str(v, *, errors='surrogateescape'):
     """we know that we want str and the value should be str"""
     if isinstance(v, bytes):
         v = v.decode('utf-8', errors=errors)
-    assert isinstance(v, str)
+    assert isinstance(v, str), f'not a str object, but {v!r}'
     return v
 
 
@@ -397,7 +397,13 @@ class Item(PropDict):
             if k == 'xattrs':
                 if not isinstance(v, StableDict):
                     v = StableDict(v)
-                # TODO: xattrs key/value types
+                v_new = StableDict()
+                for xk, xv in list(v.items()):
+                    xk = want_bytes(xk)
+                    # old borg used to store None instead of a b'' value
+                    xv = b'' if xv is None else want_bytes(xv)
+                    v_new[xk] = xv
+                v = v_new  # xattrs is a StableDict(bytes keys -> bytes values)
             self._dict[k] = v
 
 
diff --git a/src/borg/xattr.py b/src/borg/xattr.py
index 8a731340c..175f6372c 100644
--- a/src/borg/xattr.py
+++ b/src/borg/xattr.py
@@ -76,9 +76,7 @@ def get_all(path, follow_symlinks=False):
         for name in names:
             try:
                 # xattr name is a bytes object, we directly use it.
-                # if we get an empty xattr value (b''), we store None into the result dict -
-                # borg always did it like that...
-                result[name] = getxattr(path, name, follow_symlinks=follow_symlinks) or None
+                result[name] = getxattr(path, name, follow_symlinks=follow_symlinks)
             except OSError as e:
                 name_str = name.decode()
                 if isinstance(path, int):
@@ -122,9 +120,7 @@ def set_all(path, xattrs, follow_symlinks=False):
     warning = False
     for k, v in xattrs.items():
         try:
-            # the key k is a bytes object due to msgpack unpacking it as such.
-            # if we have a None value, it means "empty", so give b'' to setxattr in that case:
-            setxattr(path, k, v or b'', follow_symlinks=follow_symlinks)
+            setxattr(path, k, v, follow_symlinks=follow_symlinks)
         except OSError as e:
             warning = True
             k_str = k.decode()

From f2b085787b0fb13634073b1df3979a30ac66fa5a Mon Sep 17 00:00:00 2001
From: Thomas Waldmann <tw@waldmann-edv.de>
Date: Mon, 30 May 2022 00:05:07 +0200
Subject: [PATCH 023/160] Item: disallow None value for
 .user/group/chunks/chunks_healthy

If we do not know the value, just do not have that key/value pair in the item.
---
 src/borg/archive.py             | 23 ++++++++++++++---------
 src/borg/archiver.py            |  4 ++--
 src/borg/helpers/parseformat.py |  4 ++--
 src/borg/item.pyx               |  8 ++++----
 src/borg/testsuite/item.py      |  8 --------
 5 files changed, 22 insertions(+), 25 deletions(-)

diff --git a/src/borg/archive.py b/src/borg/archive.py
index ff6ca7ce6..e068413f5 100644
--- a/src/borg/archive.py
+++ b/src/borg/archive.py
@@ -392,14 +392,14 @@ def get_item_uid_gid(item, *, numeric, uid_forced=None, gid_forced=None, uid_def
     if uid_forced is not None:
         uid = uid_forced
     else:
-        uid = None if numeric else user2uid(item.user)
+        uid = None if numeric else user2uid(item.get('user'))
         uid = item.uid if uid is None else uid
         if uid < 0:
             uid = uid_default
     if gid_forced is not None:
         gid = gid_forced
     else:
-        gid = None if numeric else group2gid(item.group)
+        gid = None if numeric else group2gid(item.get('group'))
         gid = item.gid if gid is None else gid
         if gid < 0:
             gid = gid_default
@@ -1089,11 +1089,13 @@ class MetadataCollector:
         if not self.nobirthtime and hasattr(st, 'st_birthtime'):
             # sadly, there's no stat_result.st_birthtime_ns
             attrs['birthtime'] = safe_ns(int(st.st_birthtime * 10**9))
-        if self.numeric_ids:
-            attrs['user'] = attrs['group'] = None
-        else:
-            attrs['user'] = uid2user(st.st_uid)
-            attrs['group'] = gid2group(st.st_gid)
+        if not self.numeric_ids:
+            user = uid2user(st.st_uid)
+            if user is not None:
+                attrs['user'] = user
+            group = gid2group(st.st_gid)
+            if group is not None:
+                attrs['group'] = group
         return attrs
 
     def stat_ext_attrs(self, st, path, fd=None):
@@ -1426,8 +1428,11 @@ class TarfileObjectProcessors:
                 return safe_ns(int(float(s) * 1e9))
 
             item = Item(path=make_path_safe(tarinfo.name), mode=tarinfo.mode | type,
-                        uid=tarinfo.uid, gid=tarinfo.gid, user=tarinfo.uname or None, group=tarinfo.gname or None,
-                        mtime=s_to_ns(tarinfo.mtime))
+                        uid=tarinfo.uid, gid=tarinfo.gid, mtime=s_to_ns(tarinfo.mtime))
+            if tarinfo.uname:
+                item.user = tarinfo.uname
+            if tarinfo.gname:
+                item.group = tarinfo.gname
             if ph:
                 # note: for mtime this is a bit redundant as it is already done by tarfile module,
                 #       but we just do it in our way to be consistent for sure.
diff --git a/src/borg/archiver.py b/src/borg/archiver.py
index 7ac3c7e6d..8d5513973 100644
--- a/src/borg/archiver.py
+++ b/src/borg/archiver.py
@@ -1355,8 +1355,8 @@ class Archiver:
             tarinfo.mode = stat.S_IMODE(item.mode)
             tarinfo.uid = item.uid
             tarinfo.gid = item.gid
-            tarinfo.uname = item.user or ''
-            tarinfo.gname = item.group or ''
+            tarinfo.uname = item.get('user', '')
+            tarinfo.gname = item.get('group',  '')
             # The linkname in tar has 2 uses:
             # for symlinks it means the destination, while for hardlinks it refers to the file.
             # Since hardlinks in tar have a different type code (LNKTYPE) the format might
diff --git a/src/borg/helpers/parseformat.py b/src/borg/helpers/parseformat.py
index 414402de0..e772f38c4 100644
--- a/src/borg/helpers/parseformat.py
+++ b/src/borg/helpers/parseformat.py
@@ -808,8 +808,8 @@ class ItemFormatter(BaseFormatter):
         hlid = bin_to_hex(hlid) if hlid else ''
         item_data['type'] = item_type
         item_data['mode'] = mode
-        item_data['user'] = item.user or item.uid
-        item_data['group'] = item.group or item.gid
+        item_data['user'] = item.get('user', str(item.uid))
+        item_data['group'] = item.get('group', str(item.gid))
         item_data['uid'] = item.uid
         item_data['gid'] = item.gid
         item_data['path'] = remove_surrogates(item.path)
diff --git a/src/borg/item.pyx b/src/borg/item.pyx
index c3f59ed27..1822cf9de 100644
--- a/src/borg/item.pyx
+++ b/src/borg/item.pyx
@@ -249,8 +249,8 @@ class Item(PropDict):
 
     path = PropDict._make_property('path', str, 'surrogate-escaped str')
     source = PropDict._make_property('source', str, 'surrogate-escaped str')
-    user = PropDict._make_property('user', (str, type(None)), 'surrogate-escaped str or None')
-    group = PropDict._make_property('group', (str, type(None)), 'surrogate-escaped str or None')
+    user = PropDict._make_property('user', str, 'surrogate-escaped str')
+    group = PropDict._make_property('group', str, 'surrogate-escaped str')
 
     acl_access = PropDict._make_property('acl_access', bytes)
     acl_default = PropDict._make_property('acl_default', bytes)
@@ -274,8 +274,8 @@ class Item(PropDict):
     hlid = PropDict._make_property('hlid', bytes)  # hard link id: same value means same hard link.
     hardlink_master = PropDict._make_property('hardlink_master', bool)  # legacy
 
-    chunks = PropDict._make_property('chunks', (list, type(None)), 'list or None')
-    chunks_healthy = PropDict._make_property('chunks_healthy', (list, type(None)), 'list or None')
+    chunks = PropDict._make_property('chunks', list, 'list')
+    chunks_healthy = PropDict._make_property('chunks_healthy', list, 'list')
 
     xattrs = PropDict._make_property('xattrs', StableDict)
 
diff --git a/src/borg/testsuite/item.py b/src/borg/testsuite/item.py
index 94167e7ea..a0c1d9d13 100644
--- a/src/borg/testsuite/item.py
+++ b/src/borg/testsuite/item.py
@@ -89,14 +89,6 @@ def test_item_mptimestamp_property():
     assert item.as_dict() == {'atime': Timestamp.from_unix_nano(big)}
 
 
-def test_item_user_group_none():
-    item = Item()
-    item.user = None
-    assert item.user is None
-    item.group = None
-    assert item.group is None
-
-
 def test_item_se_str_property():
     # start simple
     item = Item()

From ed22f721f3e43e7800173d87b7a1d4cefedbff8e Mon Sep 17 00:00:00 2001
From: Thomas Waldmann <tw@waldmann-edv.de>
Date: Mon, 30 May 2022 13:32:11 +0200
Subject: [PATCH 024/160] EncryptedKey: fix once, remove decode=...

---
 src/borg/item.pyx | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/src/borg/item.pyx b/src/borg/item.pyx
index 1822cf9de..5e6e401f5 100644
--- a/src/borg/item.pyx
+++ b/src/borg/item.pyx
@@ -427,9 +427,9 @@ class EncryptedKey(PropDict):
     version = PropDict._make_property('version', int)
     algorithm = PropDict._make_property('algorithm', str)
     iterations = PropDict._make_property('iterations', int)
-    salt = PropDict._make_property('salt', bytes, decode=want_bytes)
-    hash = PropDict._make_property('hash', bytes, decode=want_bytes)
-    data = PropDict._make_property('data', bytes, decode=want_bytes)
+    salt = PropDict._make_property('salt', bytes)
+    hash = PropDict._make_property('hash', bytes)
+    data = PropDict._make_property('data', bytes)
     argon2_time_cost = PropDict._make_property('argon2_time_cost', int)
     argon2_memory_cost = PropDict._make_property('argon2_memory_cost', int)
     argon2_parallelism = PropDict._make_property('argon2_parallelism', int)
@@ -443,6 +443,8 @@ class EncryptedKey(PropDict):
                 assert isinstance(v, int)
             if k in ('algorithm', 'argon2_type'):
                 v = fix_str_value(d, k)
+            if k in ('salt', 'hash', 'data'):
+                v = fix_bytes_value(d, k)
             self._dict[k] = v
 
 

From 58009f6773c5658a3b0dc7b8fd8c956f7ed158c8 Mon Sep 17 00:00:00 2001
From: Thomas Waldmann <tw@waldmann-edv.de>
Date: Mon, 30 May 2022 13:38:05 +0200
Subject: [PATCH 025/160] Key: fix once, remove decode=...

---
 src/borg/item.pyx | 10 ++++++----
 1 file changed, 6 insertions(+), 4 deletions(-)

diff --git a/src/borg/item.pyx b/src/borg/item.pyx
index 5e6e401f5..169aec048 100644
--- a/src/borg/item.pyx
+++ b/src/borg/item.pyx
@@ -465,10 +465,10 @@ class Key(PropDict):
     __slots__ = ("_dict", )  # avoid setting attributes not supported by properties
 
     version = PropDict._make_property('version', int)
-    repository_id = PropDict._make_property('repository_id', bytes, decode=want_bytes)
-    enc_key = PropDict._make_property('enc_key', bytes, decode=want_bytes)
-    enc_hmac_key = PropDict._make_property('enc_hmac_key', bytes, decode=want_bytes)
-    id_key = PropDict._make_property('id_key', bytes, decode=want_bytes)
+    repository_id = PropDict._make_property('repository_id', bytes)
+    enc_key = PropDict._make_property('enc_key', bytes)
+    enc_hmac_key = PropDict._make_property('enc_hmac_key', bytes)
+    id_key = PropDict._make_property('id_key', bytes)
     chunk_seed = PropDict._make_property('chunk_seed', int)
     tam_required = PropDict._make_property('tam_required', bool)
 
@@ -478,6 +478,8 @@ class Key(PropDict):
             k = fix_key(d, k)
             if k == 'version':
                 assert isinstance(v, int)
+            if k in ('repository_id', 'enc_key', 'enc_hmac_key', 'id_key'):
+                v = fix_bytes_value(d, k)
             self._dict[k] = v
 
 

From 421d4bdfb05f0917f1337ad0e00f8cfaa6952d61 Mon Sep 17 00:00:00 2001
From: Thomas Waldmann <tw@waldmann-edv.de>
Date: Mon, 30 May 2022 23:22:48 +0200
Subject: [PATCH 026/160] docs: fix bytes -> str in data-structures docs

---
 docs/internals/data-structures.rst | 38 +++++++++++++++---------------
 1 file changed, 19 insertions(+), 19 deletions(-)

diff --git a/docs/internals/data-structures.rst b/docs/internals/data-structures.rst
index d1a5a4cd3..8de20761b 100644
--- a/docs/internals/data-structures.rst
+++ b/docs/internals/data-structures.rst
@@ -329,17 +329,17 @@ or modified. It looks like this:
 .. code-block:: python
 
     {
-        b'version': 1,
-        b'timestamp': b'2017-05-05T12:42:23.042864',
-        b'item_keys': [b'acl_access', b'acl_default', ...],
-        b'config': {},
-        b'archives': {
-            b'2017-05-05-system-backup': {
-                b'id': b'<32 byte binary object ID>',
-                b'time': b'2017-05-05T12:42:22.942864',
+        'version': 1,
+        'timestamp': '2017-05-05T12:42:23.042864',
+        'item_keys': ['acl_access', 'acl_default', ...],
+        'config': {},
+        'archives': {
+            '2017-05-05-system-backup': {
+                'id': b'<32 byte binary object ID>',
+                'time': '2017-05-05T12:42:22.942864',
             },
         },
-        b'tam': ...,
+        'tam': ...,
     }
 
 The *version* field can be either 1 or 2. The versions differ in the
@@ -393,15 +393,15 @@ The *config* key stores the feature flags enabled on a repository:
 .. code-block:: python
 
     config = {
-        b'feature_flags': {
-            b'read': {
-                b'mandatory': [b'some_feature'],
+        'feature_flags': {
+            'read': {
+                'mandatory': ['some_feature'],
             },
-            b'check': {
-                b'mandatory': [b'other_feature'],
+            'check': {
+                'mandatory': ['other_feature'],
             }
-            b'write': ...,
-            b'delete': ...
+            'write': ...,
+            'delete': ...
         },
     }
 
@@ -1220,9 +1220,9 @@ transaction ID in the file names. Integrity data is stored in a third file
 .. code-block:: python
 
     {
-        b'version': 2,
-        b'hints': b'{"algorithm": "XXH64", "digests": {"final": "411208db2aa13f1a"}}',
-        b'index': b'{"algorithm": "XXH64", "digests": {"HashHeader": "846b7315f91b8e48", "final": "cb3e26cadc173e40"}}'
+        'version': 2,
+        'hints': '{"algorithm": "XXH64", "digests": {"final": "411208db2aa13f1a"}}',
+        'index': '{"algorithm": "XXH64", "digests": {"HashHeader": "846b7315f91b8e48", "final": "cb3e26cadc173e40"}}'
     }
 
 The *version* key started at 2, the same version used for the hints. Since Borg has

From 08228fbd32cc29822085be9fd43926f0d4fb79fa Mon Sep 17 00:00:00 2001
From: Thomas Waldmann <tw@waldmann-edv.de>
Date: Tue, 31 May 2022 00:07:01 +0200
Subject: [PATCH 027/160] Item: remove unused hardlink_masters param

---
 src/borg/item.pyx | 25 +++----------------------
 1 file changed, 3 insertions(+), 22 deletions(-)

diff --git a/src/borg/item.pyx b/src/borg/item.pyx
index 169aec048..cd1a3544c 100644
--- a/src/borg/item.pyx
+++ b/src/borg/item.pyx
@@ -284,12 +284,10 @@ class Item(PropDict):
 
     part = PropDict._make_property('part', int)
 
-    def get_size(self, hardlink_masters=None, memorize=False, compressed=False, from_chunks=False, consider_ids=None):
+    def get_size(self, memorize=False, compressed=False, from_chunks=False, consider_ids=None):
         """
         Determine the (uncompressed or compressed) size of this item.
 
-        :param hardlink_masters: If given, the size of hardlink slaves is computed via the hardlink master's chunk list,
-        otherwise size will be returned as 0.
         :param memorize: Whether the computed size value will be stored into the item.
         :param compressed: Whether the compressed or uncompressed size will be returned.
         :param from_chunks: If true, size is computed from chunks even if a precomputed value is available.
@@ -309,31 +307,14 @@ class Item(PropDict):
             # no precomputed (c)size value available, compute it:
             try:
                 chunks = getattr(self, 'chunks')
-                having_chunks = True
             except AttributeError:
-                having_chunks = False
-                # this item has no (own) chunks list, but if this is a hardlink slave
-                # and we know the master, we can still compute the size.
-                if hardlink_masters is None:
-                    chunks = None
-                else:
-                    try:
-                        master = getattr(self, 'source')
-                    except AttributeError:
-                        # not a hardlink slave, likely a directory or special file w/o chunks
-                        chunks = None
-                    else:
-                        # hardlink slave, try to fetch hardlink master's chunks list
-                        # todo: put precomputed size into hardlink_masters' values and use it, if present
-                        chunks, _ = hardlink_masters.get(master, (None, None))
-                if chunks is None:
-                    return 0
+                return 0
             if consider_ids is not None:
                 size = sum(getattr(ChunkListEntry(*chunk), attr) for chunk in chunks if chunk.id in consider_ids)
             else:
                 size = sum(getattr(ChunkListEntry(*chunk), attr) for chunk in chunks)
             # if requested, memorize the precomputed (c)size for items that have an own chunks list:
-            if memorize and having_chunks:
+            if memorize:
                 setattr(self, attr, size)
         return size
 

From d4ee968b07b8cf4971049d13af8ed56d6ef7b5d1 Mon Sep 17 00:00:00 2001
From: Thomas Waldmann <tw@waldmann-edv.de>
Date: Thu, 9 Jun 2022 18:13:40 +0200
Subject: [PATCH 028/160] use borg 2.0 to refer to this, not 1.3

also, some type conversions are now done in update_internal once,
not in the decode methods of the classes in item.pyx.
---
 src/borg/constants.py       |  2 +-
 src/borg/helpers/msgpack.py | 13 +++++++------
 2 files changed, 8 insertions(+), 7 deletions(-)

diff --git a/src/borg/constants.py b/src/borg/constants.py
index 13eb8bd23..d2fa11919 100644
--- a/src/borg/constants.py
+++ b/src/borg/constants.py
@@ -128,7 +128,7 @@ class KeyType:
     # upper 4 bits are ciphersuite, 0 == legacy AES-CTR
     KEYFILE = 0x00
     # repos with PASSPHRASE mode could not be created any more since borg 1.0, see #97.
-    # in borg 1.3 all of its code and also the "borg key migrate-to-repokey" command was removed.
+    # in borg 2. all of its code and also the "borg key migrate-to-repokey" command was removed.
     # if you still need to, you can use "borg key migrate-to-repokey" with borg 1.0, 1.1 and 1.2.
     # Nowadays, we just dispatch this to RepoKey and assume the passphrase was migrated to a repokey.
     PASSPHRASE = 0x01  # legacy, attic and borg < 1.0
diff --git a/src/borg/helpers/msgpack.py b/src/borg/helpers/msgpack.py
index 4e79c0274..ffb87be03 100644
--- a/src/borg/helpers/msgpack.py
+++ b/src/borg/helpers/msgpack.py
@@ -6,7 +6,7 @@ We wrap msgpack here the way we need it - to avoid having lots of clutter in the
 
 Packing
 -------
-- use_bin_type = True (used by borg since borg 1.3)
+- use_bin_type = True (used by borg since borg 2.0)
   This is used to generate output according to new msgpack 2.0 spec.
   This cleanly keeps bytes and str types apart.
 
@@ -21,16 +21,17 @@ Packing
 
 Unpacking
 ---------
-- raw = False (used by borg since borg 1.3)
-  We already can use this with borg 1.3 due to the want_bytes decoder.
-  This decoder can be removed in future, when we do not have to deal with data any more that was packed the old way.
+- raw = False (used by borg since borg 2.0)
+  We already can use this with borg 2.0 due to the type conversion to the desired type in item.py update_internal
+  methods. This type conversion code can be removed in future, when we do not have to deal with data any more
+  that was packed the old way.
   It will then unpack according to the msgpack 2.0 spec format and directly output bytes or str.
 
 - raw = True (the old way, used by borg < 1.3)
 
 - unicode_errors = 'surrogateescape' -> see description above (will be used when raw is False).
 
-As of borg 1.3, we have fixed most of the msgpack str/bytes mess, #968.
+As of borg 2.0, we have fixed most of the msgpack str/bytes mess, #968.
 Borg now still needs to **read** old repos, archives, keys, ... so we can not yet fix it completely.
 But from now on, borg only **writes** new data according to the new msgpack 2.0 spec,
 thus we can remove some legacy support in a later borg release (some places are marked with "legacy").
@@ -41,7 +42,7 @@ current way in msgpack terms
 - pack with use_bin_type=True (according to msgpack 2.0 spec)
 - packs str -> raw and bytes -> bin
 - unpack with raw=False (according to msgpack 2.0 spec, using unicode_errors='surrogateescape')
-- unpacks bin to bytes and raw to str (thus we need to re-encode manually if we want bytes from "raw")
+- unpacks bin to bytes and raw to str (thus we need to convert to desired type if we want bytes from "raw")
 """
 
 from .datastruct import StableDict

From b9f9623a6d7301b0586df226b05ed81d032f77c5 Mon Sep 17 00:00:00 2001
From: Thomas Waldmann <tw@waldmann-edv.de>
Date: Fri, 10 Jun 2022 15:59:29 +0200
Subject: [PATCH 029/160] prepare to remove csize (set it to 0 for now)

---
 src/borg/archive.py             | 114 +++++++-------------------------
 src/borg/archiver.py            |   6 +-
 src/borg/cache.py               |  84 +++++------------------
 src/borg/constants.py           |   2 +-
 src/borg/hashindex.pyx          |   2 -
 src/borg/helpers/parseformat.py |  14 +---
 src/borg/item.pyx               |   5 +-
 src/borg/testsuite/archive.py   |  23 +++----
 src/borg/testsuite/archiver.py  |  91 +++----------------------
 src/borg/testsuite/hashindex.py |   4 +-
 src/borg/testsuite/item.py      |   8 +--
 11 files changed, 74 insertions(+), 279 deletions(-)

diff --git a/src/borg/archive.py b/src/borg/archive.py
index e068413f5..b2aabfee6 100644
--- a/src/borg/archive.py
+++ b/src/borg/archive.py
@@ -58,60 +58,46 @@ class Statistics:
     def __init__(self, output_json=False, iec=False):
         self.output_json = output_json
         self.iec = iec
-        self.osize = self.csize = self.usize = self.nfiles = 0
-        self.osize_parts = self.csize_parts = self.usize_parts = self.nfiles_parts = 0
+        self.osize = self.nfiles = 0
+        self.osize_parts = self.nfiles_parts = 0
         self.last_progress = 0  # timestamp when last progress was shown
 
-    def update(self, size, csize, unique, part=False):
+    def update(self, size, part=False):
         if not part:
             self.osize += size
-            self.csize += csize
-            if unique:
-                self.usize += csize
         else:
             self.osize_parts += size
-            self.csize_parts += csize
-            if unique:
-                self.usize_parts += csize
 
     def __add__(self, other):
         if not isinstance(other, Statistics):
             raise TypeError('can only add Statistics objects')
         stats = Statistics(self.output_json, self.iec)
         stats.osize = self.osize + other.osize
-        stats.csize = self.csize + other.csize
-        stats.usize = self.usize + other.usize
         stats.nfiles = self.nfiles + other.nfiles
         stats.osize_parts = self.osize_parts + other.osize_parts
-        stats.csize_parts = self.csize_parts + other.csize_parts
-        stats.usize_parts = self.usize_parts + other.usize_parts
         stats.nfiles_parts = self.nfiles_parts + other.nfiles_parts
         return stats
 
-    summary = "{label:15} {stats.osize_fmt:>20s} {stats.csize_fmt:>20s} {stats.usize_fmt:>20s}"
+    summary = "{label:15} {stats.osize_fmt:>20s}"
 
     def __str__(self):
         return self.summary.format(stats=self, label='This archive:')
 
     def __repr__(self):
-        return "<{cls} object at {hash:#x} ({self.osize}, {self.csize}, {self.usize})>".format(
+        return "<{cls} object at {hash:#x} ({self.osize})>".format(
             cls=type(self).__name__, hash=id(self), self=self)
 
     def as_dict(self):
         return {
             'original_size': FileSize(self.osize, iec=self.iec),
-            'compressed_size': FileSize(self.csize, iec=self.iec),
-            'deduplicated_size': FileSize(self.usize, iec=self.iec),
             'nfiles': self.nfiles,
         }
 
     def as_raw_dict(self):
         return {
             'size': self.osize,
-            'csize': self.csize,
             'nfiles': self.nfiles,
             'size_parts': self.osize_parts,
-            'csize_parts': self.csize_parts,
             'nfiles_parts': self.nfiles_parts,
         }
 
@@ -119,10 +105,8 @@ class Statistics:
     def from_raw_dict(cls, **kw):
         self = cls()
         self.osize = kw['size']
-        self.csize = kw['csize']
         self.nfiles = kw['nfiles']
         self.osize_parts = kw['size_parts']
-        self.csize_parts = kw['csize_parts']
         self.nfiles_parts = kw['nfiles_parts']
         return self
 
@@ -130,14 +114,6 @@ class Statistics:
     def osize_fmt(self):
         return format_file_size(self.osize, iec=self.iec)
 
-    @property
-    def usize_fmt(self):
-        return format_file_size(self.usize, iec=self.iec)
-
-    @property
-    def csize_fmt(self):
-        return format_file_size(self.csize, iec=self.iec)
-
     def show_progress(self, item=None, final=False, stream=None, dt=None):
         now = time.monotonic()
         if dt is None or now - self.last_progress > dt:
@@ -158,7 +134,7 @@ class Statistics:
             else:
                 columns, lines = get_terminal_size()
                 if not final:
-                    msg = '{0.osize_fmt} O {0.csize_fmt} C {0.usize_fmt} D {0.nfiles} N '.format(self)
+                    msg = '{0.osize_fmt} O {0.nfiles} N '.format(self)
                     path = remove_surrogates(item.path) if item else ''
                     space = columns - swidth(msg)
                     if space < 12:
@@ -614,10 +590,8 @@ Utilization of max. archive size: {csize_max:.0%}
         if stats is not None:
             metadata.update({
                 'size': stats.osize,
-                'csize': stats.csize,
                 'nfiles': stats.nfiles,
                 'size_parts': stats.osize_parts,
-                'csize_parts': stats.csize_parts,
                 'nfiles_parts': stats.nfiles_parts})
         metadata.update(additional_metadata or {})
         metadata = ArchiveItem(metadata)
@@ -651,51 +625,12 @@ Utilization of max. archive size: {csize_max:.0%}
         return stats
 
     def _calc_stats(self, cache, want_unique=True):
-        have_borg12_meta = self.metadata.get('nfiles') is not None
-
-        if have_borg12_meta and not want_unique:
-            unique_csize = 0
-        else:
-            def add(id):
-                entry = cache.chunks[id]
-                archive_index.add(id, 1, entry.size, entry.csize)
-
-            archive_index = ChunkIndex()
-            sync = CacheSynchronizer(archive_index)
-            add(self.id)
-            # we must escape any % char in the archive name, because we use it in a format string, see #6500
-            arch_name_escd = self.name.replace('%', '%%')
-            pi = ProgressIndicatorPercent(total=len(self.metadata.items),
-                                          msg='Calculating statistics for archive %s ... %%3.0f%%%%' % arch_name_escd,
-                                          msgid='archive.calc_stats')
-            for id, chunk in zip(self.metadata.items, self.repository.get_many(self.metadata.items)):
-                pi.show(increase=1)
-                add(id)
-                data = self.key.decrypt(id, chunk)
-                sync.feed(data)
-            unique_csize = archive_index.stats_against(cache.chunks)[3]
-            pi.finish()
-
         stats = Statistics(iec=self.iec)
-        stats.usize = unique_csize  # the part files use same chunks as the full file
-        if not have_borg12_meta:
-            if self.consider_part_files:
-                stats.nfiles = sync.num_files_totals
-                stats.osize = sync.size_totals
-                stats.csize = sync.csize_totals
-            else:
-                stats.nfiles = sync.num_files_totals - sync.num_files_parts
-                stats.osize = sync.size_totals - sync.size_parts
-                stats.csize = sync.csize_totals - sync.csize_parts
-        else:
-            if self.consider_part_files:
-                stats.nfiles = self.metadata.nfiles_parts + self.metadata.nfiles
-                stats.osize = self.metadata.size_parts + self.metadata.size
-                stats.csize = self.metadata.csize_parts + self.metadata.csize
-            else:
-                stats.nfiles = self.metadata.nfiles
-                stats.osize = self.metadata.size
-                stats.csize = self.metadata.csize
+        stats.nfiles = self.metadata.nfiles
+        stats.osize = self.metadata.size
+        if self.consider_part_files:
+            stats.nfiles += self.metadata.nfiles_parts
+            stats.osize += self.metadata.size_parts
         return stats
 
     @contextmanager
@@ -986,7 +921,7 @@ Utilization of max. archive size: {csize_max:.0%}
                         item = Item(internal_dict=item)
                         if 'chunks' in item:
                             part = not self.consider_part_files and 'part' in item
-                            for chunk_id, size, csize in item.chunks:
+                            for chunk_id, size, _ in item.chunks:
                                 chunk_decref(chunk_id, stats, part=part)
                 except (TypeError, ValueError):
                     # if items metadata spans multiple chunks and one chunk got dropped somehow,
@@ -1789,15 +1724,15 @@ class ArchiveChecker:
         def add_callback(chunk):
             id_ = self.key.id_hash(chunk)
             cdata = self.key.encrypt(id_, chunk)
-            add_reference(id_, len(chunk), len(cdata), cdata)
+            add_reference(id_, len(chunk), cdata)
             return id_
 
-        def add_reference(id_, size, csize, cdata=None):
+        def add_reference(id_, size, cdata=None):
             try:
                 self.chunks.incref(id_)
             except KeyError:
                 assert cdata is not None
-                self.chunks[id_] = ChunkIndexEntry(refcount=1, size=size, csize=csize)
+                self.chunks[id_] = ChunkIndexEntry(refcount=1, size=size, csize=0)  # was: csize=csize
                 if self.repair:
                     self.repository.put(id_, cdata)
 
@@ -1811,8 +1746,7 @@ class ArchiveChecker:
                 chunk = Chunk(None, allocation=CH_ALLOC, size=size)
                 chunk_id, data = cached_hash(chunk, self.key.id_hash)
                 cdata = self.key.encrypt(chunk_id, data)
-                csize = len(cdata)
-                return chunk_id, size, csize, cdata
+                return chunk_id, size, cdata
 
             offset = 0
             chunk_list = []
@@ -1835,30 +1769,30 @@ class ArchiveChecker:
                                      'Replacing with all-zero chunk.'.format(
                                      archive_name, item.path, offset, offset + size, bin_to_hex(chunk_id)))
                         self.error_found = chunks_replaced = True
-                        chunk_id, size, csize, cdata = replacement_chunk(size)
-                        add_reference(chunk_id, size, csize, cdata)
+                        chunk_id, size, cdata = replacement_chunk(size)
+                        add_reference(chunk_id, size, cdata)
                     else:
                         logger.info('{}: {}: Previously missing file chunk is still missing (Byte {}-{}, Chunk {}). '
                                     'It has an all-zero replacement chunk already.'.format(
                                     archive_name, item.path, offset, offset + size, bin_to_hex(chunk_id)))
                         chunk_id, size, csize = chunk_current
                         if chunk_id in self.chunks:
-                            add_reference(chunk_id, size, csize)
+                            add_reference(chunk_id, size)
                         else:
                             logger.warning('{}: {}: Missing all-zero replacement chunk detected (Byte {}-{}, Chunk {}). '
                                            'Generating new replacement chunk.'.format(
                                            archive_name, item.path, offset, offset + size, bin_to_hex(chunk_id)))
                             self.error_found = chunks_replaced = True
-                            chunk_id, size, csize, cdata = replacement_chunk(size)
-                            add_reference(chunk_id, size, csize, cdata)
+                            chunk_id, size, cdata = replacement_chunk(size)
+                            add_reference(chunk_id, size, cdata)
                 else:
                     if chunk_current == chunk_healthy:
                         # normal case, all fine.
-                        add_reference(chunk_id, size, csize)
+                        add_reference(chunk_id, size)
                     else:
                         logger.info('{}: {}: Healed previously missing file chunk! (Byte {}-{}, Chunk {}).'.format(
                             archive_name, item.path, offset, offset + size, bin_to_hex(chunk_id)))
-                        add_reference(chunk_id, size, csize)
+                        add_reference(chunk_id, size)
                         mark_as_possibly_superseded(chunk_current[0])  # maybe orphaned the all-zero replacement chunk
                 chunk_list.append([chunk_id, size, csize])  # list-typed element as chunks_healthy is list-of-lists
                 offset += size
@@ -2005,7 +1939,7 @@ class ArchiveChecker:
                 data = msgpack.packb(archive.as_dict())
                 new_archive_id = self.key.id_hash(data)
                 cdata = self.key.encrypt(new_archive_id, data)
-                add_reference(new_archive_id, len(data), len(cdata), cdata)
+                add_reference(new_archive_id, len(data), cdata)
                 self.manifest.archives[info.name] = (new_archive_id, info.ts)
             pi.finish()
 
diff --git a/src/borg/archiver.py b/src/borg/archiver.py
index 8d5513973..b46bfa3f3 100644
--- a/src/borg/archiver.py
+++ b/src/borg/archiver.py
@@ -99,7 +99,7 @@ except BaseException:
 assert EXIT_ERROR == 2, "EXIT_ERROR is not 2, as expected - fix assert AND exception handler right above this line."
 
 
-STATS_HEADER = "                       Original size      Compressed size    Deduplicated size"
+STATS_HEADER = "                       Original size"
 
 PURE_PYTHON_MSGPACK_WARNING = "Using a pure-python msgpack! This will result in lower performance."
 
@@ -1797,8 +1797,8 @@ class Archiver:
                 Command line: {command_line}
                 Utilization of maximum supported archive size: {limits[max_archive_size]:.0%}
                 ------------------------------------------------------------------------------
-                                       Original size      Compressed size    Deduplicated size
-                This archive:   {stats[original_size]:>20s} {stats[compressed_size]:>20s} {stats[deduplicated_size]:>20s}
+                                       Original size
+                This archive:   {stats[original_size]:>20s}
                 {cache}
                 """).strip().format(cache=cache, **info))
             if self.exit_code:
diff --git a/src/borg/cache.py b/src/borg/cache.py
index 58ceb541b..413e83bb4 100644
--- a/src/borg/cache.py
+++ b/src/borg/cache.py
@@ -406,7 +406,7 @@ class Cache:
 
 class CacheStatsMixin:
     str_format = """\
-All archives:   {0.total_size:>20s} {0.total_csize:>20s} {0.unique_csize:>20s}
+All archives:   {0.total_size:>20s}
 
                        Unique chunks         Total chunks
 Chunk index:    {0.total_unique_chunks:20d} {0.total_chunks:20d}"""
@@ -418,39 +418,32 @@ Chunk index:    {0.total_unique_chunks:20d} {0.total_chunks:20d}"""
     def __str__(self):
         return self.str_format.format(self.format_tuple())
 
-    Summary = namedtuple('Summary', ['total_size', 'total_csize', 'unique_size', 'unique_csize', 'total_unique_chunks',
-                                     'total_chunks'])
+    Summary = namedtuple('Summary', ['total_size', 'unique_size', 'total_unique_chunks', 'total_chunks'])
 
     def stats(self):
         from .archive import Archive
         # XXX: this should really be moved down to `hashindex.pyx`
-        total_size, total_csize, unique_size, unique_csize, total_unique_chunks, total_chunks = self.chunks.summarize()
+        total_size, _, unique_size, _, total_unique_chunks, total_chunks = self.chunks.summarize()
         # the above values have the problem that they do not consider part files,
-        # thus the total_size and total_csize might be too high (chunks referenced
+        # thus the total_size might be too high (chunks referenced
         # by the part files AND by the complete file).
-        # since borg 1.2 we have new archive metadata telling the total size and
-        # csize per archive, so we can just sum up all archives to get the "all
-        # archives" stats:
-        total_size, total_csize = 0, 0
+        # since borg 1.2 we have new archive metadata telling the total size per archive,
+        # so we can just sum up all archives to get the "all archives" stats:
+        total_size = 0
         for archive_name in self.manifest.archives:
             archive = Archive(self.repository, self.key, self.manifest, archive_name,
                               consider_part_files=self.consider_part_files)
             stats = archive.calc_stats(self, want_unique=False)
             total_size += stats.osize
-            total_csize += stats.csize
-        stats = self.Summary(total_size, total_csize, unique_size, unique_csize,
-                             total_unique_chunks, total_chunks)._asdict()
+        stats = self.Summary(total_size, unique_size, total_unique_chunks, total_chunks)._asdict()
         return stats
 
     def format_tuple(self):
         stats = self.stats()
-        for field in ['total_size', 'total_csize', 'unique_csize']:
+        for field in ['total_size', ]:
             stats[field] = format_file_size(stats[field], iec=self.iec)
         return self.Summary(**stats)
 
-    def chunks_stored_size(self):
-        return self.stats()['unique_csize']
-
 
 class LocalCache(CacheStatsMixin):
     """
@@ -679,8 +672,6 @@ class LocalCache(CacheStatsMixin):
         processed_item_metadata_bytes = 0
         processed_item_metadata_chunks = 0
         compact_chunks_archive_saved_space = 0
-        fetched_chunks_for_csize = 0
-        fetched_bytes_for_csize = 0
 
         def mkpath(id, suffix=''):
             id_hex = bin_to_hex(id)
@@ -718,39 +709,6 @@ class LocalCache(CacheStatsMixin):
             except FileNotFoundError:
                 pass
 
-        def fetch_missing_csize(chunk_idx):
-            """
-            Archives created with AdHocCache will have csize=0 in all chunk list entries whose
-            chunks were already in the repository.
-
-            Scan *chunk_idx* for entries where csize=0 and fill in the correct information.
-            """
-            nonlocal fetched_chunks_for_csize
-            nonlocal fetched_bytes_for_csize
-
-            all_missing_ids = chunk_idx.zero_csize_ids()
-            fetch_ids = []
-            if len(chunks_fetched_size_index):
-                for id_ in all_missing_ids:
-                    already_fetched_entry = chunks_fetched_size_index.get(id_)
-                    if already_fetched_entry:
-                        entry = chunk_idx[id_]._replace(csize=already_fetched_entry.csize)
-                        assert entry.size == already_fetched_entry.size, 'Chunk size mismatch'
-                        chunk_idx[id_] = entry
-                    else:
-                        fetch_ids.append(id_)
-            else:
-                fetch_ids = all_missing_ids
-
-            # This is potentially a rather expensive operation, but it's hard to tell at this point
-            # if it's a problem in practice (hence the experimental status of --no-cache-sync).
-            for id_, data in zip(fetch_ids, decrypted_repository.repository.get_many(fetch_ids)):
-                entry = chunk_idx[id_]._replace(csize=len(data))
-                chunk_idx[id_] = entry
-                chunks_fetched_size_index[id_] = entry
-                fetched_chunks_for_csize += 1
-                fetched_bytes_for_csize += len(data)
-
         def fetch_and_build_idx(archive_id, decrypted_repository, chunk_idx):
             nonlocal processed_item_metadata_bytes
             nonlocal processed_item_metadata_chunks
@@ -766,7 +724,6 @@ class LocalCache(CacheStatsMixin):
                 processed_item_metadata_chunks += 1
                 sync.feed(data)
             if self.do_cache:
-                fetch_missing_csize(chunk_idx)
                 write_archive_index(archive_id, chunk_idx)
 
         def write_archive_index(archive_id, chunk_idx):
@@ -862,12 +819,7 @@ class LocalCache(CacheStatsMixin):
                         chunk_idx = chunk_idx or ChunkIndex(usable=master_index_capacity)
                         logger.info('Fetching archive index for %s ...', archive_name)
                         fetch_and_build_idx(archive_id, decrypted_repository, chunk_idx)
-                if not self.do_cache:
-                    fetch_missing_csize(chunk_idx)
                 pi.finish()
-                logger.debug('Cache sync: had to fetch %s (%d chunks) because no archive had a csize set for them '
-                             '(due to --no-cache-sync)',
-                             format_file_size(fetched_bytes_for_csize), fetched_chunks_for_csize)
                 logger.debug('Cache sync: processed %s (%d chunks) of metadata',
                              format_file_size(processed_item_metadata_bytes), processed_item_metadata_chunks)
                 logger.debug('Cache sync: compact chunks.archive.d storage saved %s bytes',
@@ -951,10 +903,10 @@ class LocalCache(CacheStatsMixin):
         if size is None:
             raise ValueError("when giving compressed data for a new chunk, the uncompressed size must be given also")
         data = self.key.encrypt(id, chunk, compress=compress)
-        csize = len(data)
+        csize = 0  # len(data)
         self.repository.put(id, data, wait=wait)
         self.chunks.add(id, 1, size, csize)
-        stats.update(size, csize, not refcount)
+        stats.update(size)
         return ChunkListEntry(id, size, csize)
 
     def seen_chunk(self, id, size=None):
@@ -970,7 +922,7 @@ class LocalCache(CacheStatsMixin):
         if not self.txn_active:
             self.begin_txn()
         count, _size, csize = self.chunks.incref(id)
-        stats.update(_size, csize, False, part=part)
+        stats.update(_size, part=part)
         return ChunkListEntry(id, _size, csize)
 
     def chunk_decref(self, id, stats, wait=True, part=False):
@@ -980,9 +932,9 @@ class LocalCache(CacheStatsMixin):
         if count == 0:
             del self.chunks[id]
             self.repository.delete(id, wait=wait)
-            stats.update(-size, -csize, True, part=part)
+            stats.update(-size, part=part)
         else:
-            stats.update(-size, -csize, False, part=part)
+            stats.update(-size, part=part)
 
     def file_known_and_unchanged(self, hashed_path, path_hash, st):
         """
@@ -1122,7 +1074,7 @@ Chunk index:    {0.total_unique_chunks:20d}             unknown"""
         csize = len(data)
         self.repository.put(id, data, wait=wait)
         self.chunks.add(id, 1, size, csize)
-        stats.update(size, csize, not refcount)
+        stats.update(size)
         return ChunkListEntry(id, size, csize)
 
     def seen_chunk(self, id, size=None):
@@ -1144,7 +1096,7 @@ Chunk index:    {0.total_unique_chunks:20d}             unknown"""
         # size or add_chunk); we can't add references to those (size=0 is invalid) and generally don't try to.
         size = _size or size
         assert size
-        stats.update(size, csize, False, part=part)
+        stats.update(size, part=part)
         return ChunkListEntry(id, size, csize)
 
     def chunk_decref(self, id, stats, wait=True, part=False):
@@ -1154,9 +1106,9 @@ Chunk index:    {0.total_unique_chunks:20d}             unknown"""
         if count == 0:
             del self.chunks[id]
             self.repository.delete(id, wait=wait)
-            stats.update(-size, -csize, True, part=part)
+            stats.update(-size, part=part)
         else:
-            stats.update(-size, -csize, False, part=part)
+            stats.update(-size, part=part)
 
     def commit(self):
         if not self._txn_active:
diff --git a/src/borg/constants.py b/src/borg/constants.py
index d2fa11919..de28cc2c1 100644
--- a/src/borg/constants.py
+++ b/src/borg/constants.py
@@ -12,7 +12,7 @@ ARCHIVE_KEYS = frozenset(['version', 'name', 'items', 'cmdline', 'hostname', 'us
                           'comment', 'chunker_params',
                           'recreate_cmdline',
                           'recreate_source_id', 'recreate_args', 'recreate_partial_chunks',  # used in 1.1.0b1 .. b2
-                          'size', 'csize', 'nfiles', 'size_parts', 'csize_parts', 'nfiles_parts', ])
+                          'size', 'nfiles', 'size_parts', 'nfiles_parts', ])
 
 # this is the set of keys that are always present in archives:
 REQUIRED_ARCHIVE_KEYS = frozenset(['version', 'name', 'items', 'cmdline', 'time', ])
diff --git a/src/borg/hashindex.pyx b/src/borg/hashindex.pyx
index 0e0ecc913..20a2a2fc5 100644
--- a/src/borg/hashindex.pyx
+++ b/src/borg/hashindex.pyx
@@ -375,9 +375,7 @@ cdef class ChunkIndex(IndexBase):
             assert refcount <= _MAX_VALUE, "invalid reference count"
             chunks += refcount
             unique_size += _le32toh(values[1])
-            unique_csize += _le32toh(values[2])
             size += <uint64_t> _le32toh(values[1]) * _le32toh(values[0])
-            csize += <uint64_t> _le32toh(values[2]) * _le32toh(values[0])
 
         return size, csize, unique_size, unique_csize, unique_chunks, chunks
 
diff --git a/src/borg/helpers/parseformat.py b/src/borg/helpers/parseformat.py
index e772f38c4..dc19590ce 100644
--- a/src/borg/helpers/parseformat.py
+++ b/src/borg/helpers/parseformat.py
@@ -698,9 +698,6 @@ class ItemFormatter(BaseFormatter):
         'source': 'link target for symlinks (identical to linktarget)',
         'hlid': 'hard link identity (same if hardlinking same fs object)',
         'extra': 'prepends {source} with " -> " for soft links and " link to " for hard links',
-        'csize': 'compressed size',
-        'dsize': 'deduplicated size',
-        'dcsize': 'deduplicated compressed size',
         'num_chunks': 'number of chunks in this file',
         'unique_chunks': 'number of unique chunks in this file',
         'xxh64': 'XXH64 checksum of this file (note: this is NOT a cryptographic hash!)',
@@ -708,7 +705,7 @@ class ItemFormatter(BaseFormatter):
     }
     KEY_GROUPS = (
         ('type', 'mode', 'uid', 'gid', 'user', 'group', 'path', 'bpath', 'source', 'linktarget', 'hlid', 'flags'),
-        ('size', 'csize', 'dsize', 'dcsize', 'num_chunks', 'unique_chunks'),
+        ('size', 'num_chunks', 'unique_chunks'),
         ('mtime', 'ctime', 'atime', 'isomtime', 'isoctime', 'isoatime'),
         tuple(sorted(hash_algorithms)),
         ('archiveid', 'archivename', 'extra'),
@@ -716,7 +713,7 @@ class ItemFormatter(BaseFormatter):
     )
 
     KEYS_REQUIRING_CACHE = (
-        'dsize', 'dcsize', 'unique_chunks',
+        'unique_chunks',
     )
 
     @classmethod
@@ -774,9 +771,6 @@ class ItemFormatter(BaseFormatter):
         self.format_keys = {f[1] for f in Formatter().parse(format)}
         self.call_keys = {
             'size': self.calculate_size,
-            'csize': self.calculate_csize,
-            'dsize': partial(self.sum_unique_chunks_metadata, lambda chunk: chunk.size),
-            'dcsize': partial(self.sum_unique_chunks_metadata, lambda chunk: chunk.csize),
             'num_chunks': self.calculate_num_chunks,
             'unique_chunks': partial(self.sum_unique_chunks_metadata, lambda chunk: 1),
             'isomtime': partial(self.format_iso_time, 'mtime'),
@@ -848,10 +842,6 @@ class ItemFormatter(BaseFormatter):
         # note: does not support hardlink slaves, they will be size 0
         return item.get_size(compressed=False)
 
-    def calculate_csize(self, item):
-        # note: does not support hardlink slaves, they will be csize 0
-        return item.get_size(compressed=True)
-
     def hash_item(self, hash_function, item):
         if 'chunks' not in item:
             return ""
diff --git a/src/borg/item.pyx b/src/borg/item.pyx
index cd1a3544c..4fc8d6814 100644
--- a/src/borg/item.pyx
+++ b/src/borg/item.pyx
@@ -293,8 +293,9 @@ class Item(PropDict):
         :param from_chunks: If true, size is computed from chunks even if a precomputed value is available.
         :param consider_ids: Returns the size of the given ids only.
         """
-        attr = 'csize' if compressed else 'size'
-        assert not (compressed and memorize), 'Item does not have a csize field.'
+        if compressed:
+            return 0  # try to live without csize
+        attr = 'size'
         assert not (consider_ids is not None and memorize), "Can't store size when considering only certain ids"
         try:
             if from_chunks or consider_ids is not None:
diff --git a/src/borg/testsuite/archive.py b/src/borg/testsuite/archive.py
index 9cdcf5046..fc67aa59e 100644
--- a/src/borg/testsuite/archive.py
+++ b/src/borg/testsuite/archive.py
@@ -19,47 +19,44 @@ from ..platform import uid2user, gid2group
 @pytest.fixture()
 def stats():
     stats = Statistics()
-    stats.update(20, 10, unique=True)
+    stats.update(20)
     return stats
 
 
 def test_stats_basic(stats):
     assert stats.osize == 20
-    assert stats.csize == stats.usize == 10
-    stats.update(20, 10, unique=False)
+    stats.update(20)
     assert stats.osize == 40
-    assert stats.csize == 20
-    assert stats.usize == 10
 
 
 def tests_stats_progress(stats, monkeypatch, columns=80):
     monkeypatch.setenv('COLUMNS', str(columns))
     out = StringIO()
     stats.show_progress(stream=out)
-    s = '20 B O 10 B C 10 B D 0 N '
+    s = '20 B O 0 N '
     buf = ' ' * (columns - len(s))
     assert out.getvalue() == s + buf + "\r"
 
     out = StringIO()
-    stats.update(10**3, 0, unique=False)
+    stats.update(10 ** 3)
     stats.show_progress(item=Item(path='foo'), final=False, stream=out)
-    s = '1.02 kB O 10 B C 10 B D 0 N foo'
+    s = '1.02 kB O 0 N foo'
     buf = ' ' * (columns - len(s))
     assert out.getvalue() == s + buf + "\r"
     out = StringIO()
     stats.show_progress(item=Item(path='foo'*40), final=False, stream=out)
-    s = '1.02 kB O 10 B C 10 B D 0 N foofoofoofoofoofoofoofo...oofoofoofoofoofoofoofoofoo'
+    s = '1.02 kB O 0 N foofoofoofoofoofoofoofoofoofoo...foofoofoofoofoofoofoofoofoofoofoo'
     buf = ' ' * (columns - len(s))
     assert out.getvalue() == s + buf + "\r"
 
 
 def test_stats_format(stats):
     assert str(stats) == """\
-This archive:                   20 B                 10 B                 10 B"""
+This archive:                   20 B"""
     s = f"{stats.osize_fmt}"
     assert s == "20 B"
     # kind of redundant, but id is variable so we can't match reliably
-    assert repr(stats) == f'<Statistics object at {id(stats):#x} (20, 10, 10)>'
+    assert repr(stats) == f'<Statistics object at {id(stats):#x} (20)>'
 
 
 def test_stats_progress_json(stats):
@@ -73,8 +70,6 @@ def test_stats_progress_json(stats):
     assert result['finished'] is False
     assert result['path'] == 'foo'
     assert result['original_size'] == 20
-    assert result['compressed_size'] == 10
-    assert result['deduplicated_size'] == 10
     assert result['nfiles'] == 0  # this counter gets updated elsewhere
 
     out = StringIO()
@@ -85,8 +80,6 @@ def test_stats_progress_json(stats):
     assert result['finished'] is True  # see #6570
     assert 'path' not in result
     assert 'original_size' not in result
-    assert 'compressed_size' not in result
-    assert 'deduplicated_size' not in result
     assert 'nfiles' not in result
 
 
diff --git a/src/borg/testsuite/archiver.py b/src/borg/testsuite/archiver.py
index a4205ea76..4789f8e47 100644
--- a/src/borg/testsuite/archiver.py
+++ b/src/borg/testsuite/archiver.py
@@ -1543,7 +1543,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         cache = info_repo['cache']
         stats = cache['stats']
         assert all(isinstance(o, int) for o in stats.values())
-        assert all(key in stats for key in ('total_chunks', 'total_csize', 'total_size', 'total_unique_chunks', 'unique_csize', 'unique_size'))
+        assert all(key in stats for key in ('total_chunks', 'total_size', 'total_unique_chunks', 'unique_size'))
 
         info_archive = json.loads(self.cmd('info', '--json', self.repository_location + '::test'))
         assert info_repo['repository'] == info_archive['repository']
@@ -2363,12 +2363,9 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self.cmd('init', '--encryption=repokey', self.repository_location)
         test_archive = self.repository_location + '::test'
         self.cmd('create', '-C', 'lz4', test_archive, 'input')
-        output = self.cmd('list', '--format', '{size} {csize} {dsize} {dcsize} {path}{NL}', test_archive)
-        size, csize, dsize, dcsize, path = output.split("\n")[1].split(" ")
-        assert int(csize) < int(size)
-        assert int(dcsize) < int(dsize)
-        assert int(dsize) <= int(size)
-        assert int(dcsize) <= int(csize)
+        output = self.cmd('list', '--format', '{size} {path}{NL}', test_archive)
+        size, path = output.split("\n")[1].split(" ")
+        assert int(size) == 10000
 
     def test_list_json(self):
         self.create_regular_file('file1', size=1024 * 80)
@@ -2441,69 +2438,6 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         log = self.cmd('--debug', 'create', self.repository_location + '::test', 'input')
         assert 'security: read previous location' in log
 
-    def _get_sizes(self, compression, compressible, size=10000):
-        if compressible:
-            contents = b'X' * size
-        else:
-            contents = os.urandom(size)
-        self.create_regular_file('file', contents=contents)
-        self.cmd('init', '--encryption=none', self.repository_location)
-        archive = self.repository_location + '::test'
-        self.cmd('create', '-C', compression, archive, 'input')
-        output = self.cmd('list', '--format', '{size} {csize} {path}{NL}', archive)
-        size, csize, path = output.split("\n")[1].split(" ")
-        return int(size), int(csize)
-
-    def test_compression_none_compressible(self):
-        size, csize = self._get_sizes('none', compressible=True)
-        assert csize == size + 3
-
-    def test_compression_none_uncompressible(self):
-        size, csize = self._get_sizes('none', compressible=False)
-        assert csize == size + 3
-
-    def test_compression_zlib_compressible(self):
-        size, csize = self._get_sizes('zlib', compressible=True)
-        assert csize < size * 0.1
-        assert csize == 37
-
-    def test_compression_zlib_uncompressible(self):
-        size, csize = self._get_sizes('zlib', compressible=False)
-        assert csize >= size
-
-    def test_compression_auto_compressible(self):
-        size, csize = self._get_sizes('auto,zlib', compressible=True)
-        assert csize < size * 0.1
-        assert csize == 37  # same as compression 'zlib'
-
-    def test_compression_auto_uncompressible(self):
-        size, csize = self._get_sizes('auto,zlib', compressible=False)
-        assert csize == size + 3  # same as compression 'none'
-
-    def test_compression_lz4_compressible(self):
-        size, csize = self._get_sizes('lz4', compressible=True)
-        assert csize < size * 0.1
-
-    def test_compression_lz4_uncompressible(self):
-        size, csize = self._get_sizes('lz4', compressible=False)
-        assert csize == size + 3  # same as compression 'none'
-
-    def test_compression_lzma_compressible(self):
-        size, csize = self._get_sizes('lzma', compressible=True)
-        assert csize < size * 0.1
-
-    def test_compression_lzma_uncompressible(self):
-        size, csize = self._get_sizes('lzma', compressible=False)
-        assert csize == size + 3  # same as compression 'none'
-
-    def test_compression_zstd_compressible(self):
-        size, csize = self._get_sizes('zstd', compressible=True)
-        assert csize < size * 0.1
-
-    def test_compression_zstd_uncompressible(self):
-        size, csize = self._get_sizes('zstd', compressible=False)
-        assert csize == size + 3  # same as compression 'none'
-
     def test_change_passphrase(self):
         self.cmd('init', '--encryption=repokey', self.repository_location)
         os.environ['BORG_NEW_PASSPHRASE'] = 'newpassphrase'
@@ -2951,13 +2885,12 @@ class ArchiverTestCase(ArchiverTestCaseBase):
                 correct_chunks = cache.chunks
         assert original_chunks is not correct_chunks
         seen = set()
-        for id, (refcount, size, csize) in correct_chunks.iteritems():
-            o_refcount, o_size, o_csize = original_chunks[id]
+        for id, (refcount, size, _) in correct_chunks.iteritems():
+            o_refcount, o_size, _ = original_chunks[id]
             assert refcount == o_refcount
             assert size == o_size
-            assert csize == o_csize
             seen.add(id)
-        for id, (refcount, size, csize) in original_chunks.iteritems():
+        for id, (refcount, size, _) in original_chunks.iteritems():
             assert id in seen
 
     def test_check_cache(self):
@@ -3051,15 +2984,13 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self.cmd('init', '--encryption=repokey', self.repository_location)
         self.cmd('create', self.repository_location + '::test', 'input', '-C', 'none')
         file_list = self.cmd('list', self.repository_location + '::test', 'input/compressible',
-                             '--format', '{size} {csize} {sha256}')
-        size, csize, sha256_before = file_list.split(' ')
-        assert int(csize) >= int(size)  # >= due to metadata overhead
+                             '--format', '{size} {sha256}')
+        size, sha256_before = file_list.split(' ')
         self.cmd('recreate', self.repository_location, '-C', 'lz4', '--recompress')
         self.check_cache()
         file_list = self.cmd('list', self.repository_location + '::test', 'input/compressible',
-                             '--format', '{size} {csize} {sha256}')
-        size, csize, sha256_after = file_list.split(' ')
-        assert int(csize) < int(size)
+                             '--format', '{size} {sha256}')
+        size, sha256_after = file_list.split(' ')
         assert sha256_before == sha256_after
 
     def test_recreate_timestamp(self):
diff --git a/src/borg/testsuite/hashindex.py b/src/borg/testsuite/hashindex.py
index 89a793a97..f16706ca9 100644
--- a/src/borg/testsuite/hashindex.py
+++ b/src/borg/testsuite/hashindex.py
@@ -147,11 +147,9 @@ class HashIndexTestCase(BaseTestCase):
         idx[H(2)] = 2, 2000, 200
         idx[H(3)] = 3, 3000, 300
 
-        size, csize, unique_size, unique_csize, unique_chunks, chunks = idx.summarize()
+        size, _, unique_size, _, unique_chunks, chunks = idx.summarize()
         assert size == 1000 + 2 * 2000 + 3 * 3000
-        assert csize == 100 + 2 * 200 + 3 * 300
         assert unique_size == 1000 + 2000 + 3000
-        assert unique_csize == 100 + 200 + 300
         assert chunks == 1 + 2 + 3
         assert unique_chunks == 3
 
diff --git a/src/borg/testsuite/item.py b/src/borg/testsuite/item.py
index a0c1d9d13..dc171afa5 100644
--- a/src/borg/testsuite/item.py
+++ b/src/borg/testsuite/item.py
@@ -143,13 +143,11 @@ def test_unknown_property():
 
 def test_item_file_size():
     item = Item(mode=0o100666, chunks=[
-        ChunkListEntry(csize=1, size=1000, id=None),
-        ChunkListEntry(csize=1, size=2000, id=None),
+        ChunkListEntry(csize=0, size=1000, id=None),
+        ChunkListEntry(csize=0, size=2000, id=None),
     ])
     assert item.get_size() == 3000
-    with pytest.raises(AssertionError):
-        item.get_size(compressed=True, memorize=True)
-    assert item.get_size(compressed=True) == 2
+    assert item.get_size(compressed=True) == 0  # no csize any more
     item.get_size(memorize=True)
     assert item.size == 3000
 

From ace5957524e0b613f11b6e393bac0db784c9268e Mon Sep 17 00:00:00 2001
From: Thomas Waldmann <tw@waldmann-edv.de>
Date: Fri, 10 Jun 2022 20:36:58 +0200
Subject: [PATCH 030/160] remove csize from item.chunks elements

---
 src/borg/archive.py              | 16 +++++-----
 src/borg/archiver.py             |  4 +--
 src/borg/cache.py                | 12 ++++----
 src/borg/cache_sync/cache_sync.c | 14 ---------
 src/borg/cache_sync/unpack.h     | 26 +++++-----------
 src/borg/fuse.py                 |  4 +--
 src/borg/hashindex.pyx           | 10 ------
 src/borg/item.pyx                |  8 ++---
 src/borg/testsuite/archive.py    |  2 +-
 src/borg/testsuite/cache.py      | 52 ++++++++++++++++----------------
 src/borg/testsuite/item.py       |  5 ++-
 11 files changed, 58 insertions(+), 95 deletions(-)

diff --git a/src/borg/archive.py b/src/borg/archive.py
index b2aabfee6..8992f42d3 100644
--- a/src/borg/archive.py
+++ b/src/borg/archive.py
@@ -359,7 +359,7 @@ class CacheChunkBuffer(ChunkBuffer):
         self.stats = stats
 
     def write_chunk(self, chunk):
-        id_, _, _ = self.cache.add_chunk(self.key.id_hash(chunk), chunk, self.stats, wait=False)
+        id_, _ = self.cache.add_chunk(self.key.id_hash(chunk), chunk, self.stats, wait=False)
         self.cache.repository.async_response(wait=False)
         return id_
 
@@ -921,7 +921,7 @@ Utilization of max. archive size: {csize_max:.0%}
                         item = Item(internal_dict=item)
                         if 'chunks' in item:
                             part = not self.consider_part_files and 'part' in item
-                            for chunk_id, size, _ in item.chunks:
+                            for chunk_id, size in item.chunks:
                                 chunk_decref(chunk_id, stats, part=part)
                 except (TypeError, ValueError):
                     # if items metadata spans multiple chunks and one chunk got dropped somehow,
@@ -1279,7 +1279,7 @@ class FilesystemObjectProcessors:
                     # this needs to be done early, so that part files also get the patched mode.
                     item.mode = stat.S_IFREG | stat.S_IMODE(item.mode)
                 if 'chunks' in item:  # create_helper might have put chunks from a previous hardlink there
-                    [cache.chunk_incref(id_, self.stats) for id_, _, _ in item.chunks]
+                    [cache.chunk_incref(id_, self.stats) for id_, _ in item.chunks]
                 else:  # normal case, no "2nd+" hardlink
                     if not is_special_file:
                         hashed_path = safe_encode(os.path.join(self.cwd, path))
@@ -1761,7 +1761,7 @@ class ArchiveChecker:
                 has_chunks_healthy = False
                 chunks_healthy = chunks_current
             for chunk_current, chunk_healthy in zip(chunks_current, chunks_healthy):
-                chunk_id, size, csize = chunk_healthy
+                chunk_id, size = chunk_healthy
                 if chunk_id not in self.chunks:
                     # a chunk of the healthy list is missing
                     if chunk_current == chunk_healthy:
@@ -1775,7 +1775,7 @@ class ArchiveChecker:
                         logger.info('{}: {}: Previously missing file chunk is still missing (Byte {}-{}, Chunk {}). '
                                     'It has an all-zero replacement chunk already.'.format(
                                     archive_name, item.path, offset, offset + size, bin_to_hex(chunk_id)))
-                        chunk_id, size, csize = chunk_current
+                        chunk_id, size = chunk_current
                         if chunk_id in self.chunks:
                             add_reference(chunk_id, size)
                         else:
@@ -1794,7 +1794,7 @@ class ArchiveChecker:
                             archive_name, item.path, offset, offset + size, bin_to_hex(chunk_id)))
                         add_reference(chunk_id, size)
                         mark_as_possibly_superseded(chunk_current[0])  # maybe orphaned the all-zero replacement chunk
-                chunk_list.append([chunk_id, size, csize])  # list-typed element as chunks_healthy is list-of-lists
+                chunk_list.append([chunk_id, size])  # list-typed element as chunks_healthy is list-of-lists
                 offset += size
             if chunks_replaced and not has_chunks_healthy:
                 # if this is first repair, remember the correct chunk IDs, so we can maybe heal the file later
@@ -2046,7 +2046,7 @@ class ArchiveRecreater:
 
     def process_chunks(self, archive, target, item):
         if not self.recompress and not target.recreate_rechunkify:
-            for chunk_id, size, csize in item.chunks:
+            for chunk_id, size in item.chunks:
                 self.cache.chunk_incref(chunk_id, target.stats)
             return item.chunks
         chunk_iterator = self.iter_chunks(archive, target, list(item.chunks))
@@ -2070,7 +2070,7 @@ class ArchiveRecreater:
         return chunk_entry
 
     def iter_chunks(self, archive, target, chunks):
-        chunk_iterator = archive.pipeline.fetch_many([chunk_id for chunk_id, _, _ in chunks])
+        chunk_iterator = archive.pipeline.fetch_many([chunk_id for chunk_id, _ in chunks])
         if target.recreate_rechunkify:
             # The target.chunker will read the file contents through ChunkIteratorFileWrapper chunk-by-chunk
             # (does not load the entire file into memory)
diff --git a/src/borg/archiver.py b/src/borg/archiver.py
index b46bfa3f3..dfc571cf4 100644
--- a/src/borg/archiver.py
+++ b/src/borg/archiver.py
@@ -424,7 +424,7 @@ class Archiver:
                 for item in other_archive.iter_items():
                     if 'chunks' in item:
                         chunks = []
-                        for chunk_id, size, _ in item.chunks:
+                        for chunk_id, size in item.chunks:
                             refcount = cache.seen_chunk(chunk_id, size)
                             if refcount == 0:  # target repo does not yet have this chunk
                                 if not dry_run:
@@ -1331,7 +1331,7 @@ class Archiver:
             """
             Return a file-like object that reads from the chunks of *item*.
             """
-            chunk_iterator = archive.pipeline.fetch_many([chunk_id for chunk_id, _, _ in item.chunks],
+            chunk_iterator = archive.pipeline.fetch_many([chunk_id for chunk_id, _ in item.chunks],
                                                          is_preloaded=True)
             if pi:
                 info = [remove_surrogates(item.path)]
diff --git a/src/borg/cache.py b/src/borg/cache.py
index 413e83bb4..59b50837a 100644
--- a/src/borg/cache.py
+++ b/src/borg/cache.py
@@ -907,7 +907,7 @@ class LocalCache(CacheStatsMixin):
         self.repository.put(id, data, wait=wait)
         self.chunks.add(id, 1, size, csize)
         stats.update(size)
-        return ChunkListEntry(id, size, csize)
+        return ChunkListEntry(id, size)
 
     def seen_chunk(self, id, size=None):
         refcount, stored_size, _ = self.chunks.get(id, ChunkIndexEntry(0, None, None))
@@ -921,14 +921,14 @@ class LocalCache(CacheStatsMixin):
     def chunk_incref(self, id, stats, size=None, part=False):
         if not self.txn_active:
             self.begin_txn()
-        count, _size, csize = self.chunks.incref(id)
+        count, _size, _ = self.chunks.incref(id)
         stats.update(_size, part=part)
-        return ChunkListEntry(id, _size, csize)
+        return ChunkListEntry(id, _size)
 
     def chunk_decref(self, id, stats, wait=True, part=False):
         if not self.txn_active:
             self.begin_txn()
-        count, size, csize = self.chunks.decref(id)
+        count, size, _ = self.chunks.decref(id)
         if count == 0:
             del self.chunks[id]
             self.repository.delete(id, wait=wait)
@@ -1075,7 +1075,7 @@ Chunk index:    {0.total_unique_chunks:20d}             unknown"""
         self.repository.put(id, data, wait=wait)
         self.chunks.add(id, 1, size, csize)
         stats.update(size)
-        return ChunkListEntry(id, size, csize)
+        return ChunkListEntry(id, size)
 
     def seen_chunk(self, id, size=None):
         if not self._txn_active:
@@ -1097,7 +1097,7 @@ Chunk index:    {0.total_unique_chunks:20d}             unknown"""
         size = _size or size
         assert size
         stats.update(size, part=part)
-        return ChunkListEntry(id, size, csize)
+        return ChunkListEntry(id, size)
 
     def chunk_decref(self, id, stats, wait=True, part=False):
         if not self._txn_active:
diff --git a/src/borg/cache_sync/cache_sync.c b/src/borg/cache_sync/cache_sync.c
index 1a2cfb0f2..300faa7a3 100644
--- a/src/borg/cache_sync/cache_sync.c
+++ b/src/borg/cache_sync/cache_sync.c
@@ -39,10 +39,8 @@ cache_sync_init(HashIndex *chunks)
     /* needs to be set only once */
     ctx->ctx.user.chunks = chunks;
     ctx->ctx.user.parts.size = 0;
-    ctx->ctx.user.parts.csize = 0;
     ctx->ctx.user.parts.num_files = 0;
     ctx->ctx.user.totals.size = 0;
-    ctx->ctx.user.totals.csize = 0;
     ctx->ctx.user.totals.num_files = 0;
     ctx->buf = NULL;
     ctx->head = 0;
@@ -91,18 +89,6 @@ cache_sync_size_parts(const CacheSyncCtx *ctx)
     return ctx->ctx.user.parts.size;
 }
 
-static uint64_t
-cache_sync_csize_totals(const CacheSyncCtx *ctx)
-{
-    return ctx->ctx.user.totals.csize;
-}
-
-static uint64_t
-cache_sync_csize_parts(const CacheSyncCtx *ctx)
-{
-    return ctx->ctx.user.parts.csize;
-}
-
 /**
  * feed data to the cache synchronizer
  * 0 = abort, 1 = continue
diff --git a/src/borg/cache_sync/unpack.h b/src/borg/cache_sync/unpack.h
index bba566419..73f86d7bd 100644
--- a/src/borg/cache_sync/unpack.h
+++ b/src/borg/cache_sync/unpack.h
@@ -86,14 +86,12 @@ typedef struct unpack_user {
 
         /*
          * processing ChunkListEntry tuple:
-         * expect_key, expect_size, expect_csize, expect_entry_end
+         * expect_key, expect_size, expect_entry_end
          */
         /* next thing must be the key (raw, l=32) */
         expect_key,
         /* next thing must be the size (int) */
         expect_size,
-        /* next thing must be the csize (int) */
-        expect_csize,
         /* next thing must be the end of the CLE (array_end) */
         expect_entry_end,
 
@@ -103,23 +101,22 @@ typedef struct unpack_user {
     /* collect values here for current chunklist entry */
     struct {
         unsigned char key[32];
-        uint32_t csize;
         uint32_t size;
     } current;
 
     /* summing up chunks sizes here within a single item */
     struct {
-        uint64_t size, csize;
+        uint64_t size;
     } item;
 
     /* total sizes and files count coming from all files */
     struct {
-        uint64_t size, csize, num_files;
+        uint64_t size, num_files;
     } totals;
 
     /* total sizes and files count coming from part files */
     struct {
-        uint64_t size, csize, num_files;
+        uint64_t size, num_files;
     } parts;
 
 } unpack_user;
@@ -147,10 +144,6 @@ static inline int unpack_callback_uint64(unpack_user* u, int64_t d)
     switch(u->expect) {
         case expect_size:
             u->current.size = d;
-            u->expect = expect_csize;
-            break;
-        case expect_csize:
-            u->current.csize = d;
             u->expect = expect_entry_end;
             break;
         default:
@@ -239,7 +232,7 @@ static inline int unpack_callback_array(unpack_user* u, unsigned int n)
     case expect_entry_begin_or_chunks_end:
         /* b'chunks': [ (
          *              ^ */
-        if(n != 3) {
+        if(n != 2) {
             SET_LAST_ERROR("Invalid chunk list entry length");
             return -1;
         }
@@ -283,18 +276,16 @@ static inline int unpack_callback_array_end(unpack_user* u)
             refcount += 1;
             cache_entry[0] = _htole32(MIN(refcount, _MAX_VALUE));
         } else {
-            /* refcount, size, csize */
+            /* refcount, size */
             cache_values[0] = _htole32(1);
             cache_values[1] = _htole32(u->current.size);
-            cache_values[2] = _htole32(u->current.csize);
+            cache_values[2] = _htole32(0);  /* fake csize for now */
             if(!hashindex_set(u->chunks, u->current.key, cache_values)) {
                 SET_LAST_ERROR("hashindex_set failed");
                 return -1;
             }
         }
         u->item.size += u->current.size;
-        u->item.csize += u->current.csize;
-
         u->expect = expect_entry_begin_or_chunks_end;
         break;
     case expect_entry_begin_or_chunks_end:
@@ -330,7 +321,6 @@ static inline int unpack_callback_map(unpack_user* u, unsigned int n)
         u->part = 0;
         u->has_chunks = 0;
         u->item.size = 0;
-        u->item.csize = 0;
     }
 
     if(u->inside_chunks) {
@@ -372,11 +362,9 @@ static inline int unpack_callback_map_end(unpack_user* u)
             if(u->part) {
                 u->parts.num_files += 1;
                 u->parts.size += u->item.size;
-                u->parts.csize += u->item.csize;
             }
             u->totals.num_files += 1;
             u->totals.size += u->item.size;
-            u->totals.csize += u->item.csize;
         }
     }
     return 0;
diff --git a/src/borg/fuse.py b/src/borg/fuse.py
index b81f37f1f..5c9f8b935 100644
--- a/src/borg/fuse.py
+++ b/src/borg/fuse.py
@@ -377,7 +377,7 @@ class FuseBackend:
                 file_id = blake2b_128(path)
                 current_version, previous_id = self.versions_index.get(file_id, (0, None))
 
-                contents_id = blake2b_128(b''.join(chunk_id for chunk_id, _, _ in item.chunks))
+                contents_id = blake2b_128(b''.join(chunk_id for chunk_id, _ in item.chunks))
 
                 if contents_id != previous_id:
                     current_version += 1
@@ -658,7 +658,7 @@ class FuseOperations(llfuse.Operations, FuseBackend):
         chunks = item.chunks
         # note: using index iteration to avoid frequently copying big (sub)lists by slicing
         for idx in range(chunk_no, len(chunks)):
-            id, s, csize = chunks[idx]
+            id, s = chunks[idx]
             if s < offset:
                 offset -= s
                 chunk_offset += s
diff --git a/src/borg/hashindex.pyx b/src/borg/hashindex.pyx
index 20a2a2fc5..6ef3a6d55 100644
--- a/src/borg/hashindex.pyx
+++ b/src/borg/hashindex.pyx
@@ -49,8 +49,6 @@ cdef extern from "cache_sync/cache_sync.c":
     uint64_t cache_sync_num_files_parts(const CacheSyncCtx *ctx)
     uint64_t cache_sync_size_totals(const CacheSyncCtx *ctx)
     uint64_t cache_sync_size_parts(const CacheSyncCtx *ctx)
-    uint64_t cache_sync_csize_totals(const CacheSyncCtx *ctx)
-    uint64_t cache_sync_csize_parts(const CacheSyncCtx *ctx)
     int cache_sync_feed(CacheSyncCtx *ctx, void *data, uint32_t length)
     void cache_sync_free(CacheSyncCtx *ctx)
 
@@ -544,11 +542,3 @@ cdef class CacheSynchronizer:
     @property
     def size_parts(self):
         return cache_sync_size_parts(self.sync)
-
-    @property
-    def csize_totals(self):
-        return cache_sync_csize_totals(self.sync)
-
-    @property
-    def csize_parts(self):
-        return cache_sync_csize_parts(self.sync)
diff --git a/src/borg/item.pyx b/src/borg/item.pyx
index 4fc8d6814..3897d2d4e 100644
--- a/src/borg/item.pyx
+++ b/src/borg/item.pyx
@@ -61,10 +61,10 @@ def fix_list_of_chunkentries(v):
     chunks = []
     for ce in v:
         assert isinstance(ce, (tuple, list))
-        assert len(ce) == 3  # id, size, csize
+        assert len(ce) in (2, 3)  # id, size[, csize]
         assert isinstance(ce[1], int)
-        assert isinstance(ce[2], int)
-        ce_fixed = [want_bytes(ce[0]), ce[1], ce[2]]  # list!
+        assert len(ce) == 2 or isinstance(ce[2], int)
+        ce_fixed = [want_bytes(ce[0]), ce[1]]  # list! id, size only, drop csize
         chunks.append(ce_fixed)  # create a list of lists
     return chunks
 
@@ -227,7 +227,7 @@ class PropDict:
         return property(_get, _set, _del, doc=doc)
 
 
-ChunkListEntry = namedtuple('ChunkListEntry', 'id size csize')
+ChunkListEntry = namedtuple('ChunkListEntry', 'id size')
 
 class Item(PropDict):
     """
diff --git a/src/borg/testsuite/archive.py b/src/borg/testsuite/archive.py
index fc67aa59e..38c4aa3d0 100644
--- a/src/borg/testsuite/archive.py
+++ b/src/borg/testsuite/archive.py
@@ -95,7 +95,7 @@ class MockCache:
 
     def add_chunk(self, id, chunk, stats=None, wait=True):
         self.objects[id] = chunk
-        return id, len(chunk), len(chunk)
+        return id, len(chunk)
 
 
 class ArchiveTimestampTestCase(BaseTestCase):
diff --git a/src/borg/testsuite/cache.py b/src/borg/testsuite/cache.py
index c67fbdf1b..d476492d8 100644
--- a/src/borg/testsuite/cache.py
+++ b/src/borg/testsuite/cache.py
@@ -43,14 +43,14 @@ class TestCacheSynchronizer:
             'bar': 5678,
             'user': 'chunks',
             'chunks': [
-                (H(1), 1, 2),
-                (H(2), 2, 3),
+                (H(1), 1),
+                (H(2), 2),
             ]
         })
         sync.feed(data)
         assert len(index) == 2
-        assert index[H(1)] == (1, 1, 2)
-        assert index[H(2)] == (1, 2, 3)
+        assert index[H(1)] == (1, 1, 0)
+        assert index[H(2)] == (1, 2, 0)
 
     def test_multiple(self, index, sync):
         data = packb({
@@ -59,8 +59,8 @@ class TestCacheSynchronizer:
             'bar': 5678,
             'user': 'chunks',
             'chunks': [
-                (H(1), 1, 2),
-                (H(2), 2, 3),
+                (H(1), 1),
+                (H(2), 2),
             ]
         })
         data += packb({
@@ -78,8 +78,8 @@ class TestCacheSynchronizer:
                 'chunks': '123456',
             },
             'chunks': [
-                (H(1), 1, 2),
-                (H(2), 2, 3),
+                (H(1), 1),
+                (H(2), 2),
             ],
             'stuff': [
                 (1, 2, 3),
@@ -87,12 +87,12 @@ class TestCacheSynchronizer:
         })
         data += packb({
             'chunks': [
-                (H(3), 1, 2),
+                (H(3), 1),
             ],
         })
         data += packb({
             'chunks': [
-                (H(1), 1, 2),
+                (H(1), 1),
             ],
         })
 
@@ -103,9 +103,9 @@ class TestCacheSynchronizer:
         sync.feed(part2)
         sync.feed(part3)
         assert len(index) == 3
-        assert index[H(1)] == (3, 1, 2)
-        assert index[H(2)] == (2, 2, 3)
-        assert index[H(3)] == (1, 1, 2)
+        assert index[H(1)] == (3, 1, 0)
+        assert index[H(2)] == (2, 2, 0)
+        assert index[H(3)] == (1, 1, 0)
 
     @pytest.mark.parametrize('elem,error', (
         ({1: 2}, 'Unexpected object: map'),
@@ -121,7 +121,7 @@ class TestCacheSynchronizer:
     @pytest.mark.parametrize('structure', (
         lambda elem: {'chunks': elem},
         lambda elem: {'chunks': [elem]},
-        lambda elem: {'chunks': [(elem, 1, 2)]},
+        lambda elem: {'chunks': [(elem, 1)]},
     ))
     def test_corrupted(self, sync, structure, elem, error):
         packed = packb(structure(elem))
@@ -135,11 +135,11 @@ class TestCacheSynchronizer:
     @pytest.mark.parametrize('data,error', (
         # Incorrect tuple length
         ({'chunks': [(bytes(32), 2, 3, 4)]}, 'Invalid chunk list entry length'),
-        ({'chunks': [(bytes(32), 2)]}, 'Invalid chunk list entry length'),
+        ({'chunks': [(bytes(32), )]}, 'Invalid chunk list entry length'),
         # Incorrect types
-        ({'chunks': [(1, 2, 3)]}, 'Unexpected object: integer'),
-        ({'chunks': [(1, bytes(32), 2)]}, 'Unexpected object: integer'),
-        ({'chunks': [(bytes(32), 1.0, 2)]}, 'Unexpected object: double'),
+        ({'chunks': [(1, 2)]}, 'Unexpected object: integer'),
+        ({'chunks': [(1, bytes(32))]}, 'Unexpected object: integer'),
+        ({'chunks': [(bytes(32), 1.0)]}, 'Unexpected object: double'),
     ))
     def test_corrupted_ancillary(self, index, sync, data, error):
         packed = packb(data)
@@ -173,7 +173,7 @@ class TestCacheSynchronizer:
         sync = CacheSynchronizer(index)
         data = packb({
             'chunks': [
-                (H(0), 1, 2),
+                (H(0), 1),
             ]
         })
         with pytest.raises(ValueError) as excinfo:
@@ -185,7 +185,7 @@ class TestCacheSynchronizer:
         sync = CacheSynchronizer(index)
         data = packb({
             'chunks': [
-                (H(0), 1, 2),
+                (H(0), 1),
             ]
         })
         sync.feed(data)
@@ -196,7 +196,7 @@ class TestCacheSynchronizer:
         sync = CacheSynchronizer(index)
         data = packb({
             'chunks': [
-                (H(0), 1, 2),
+                (H(0), 1),
             ]
         })
         sync.feed(data)
@@ -244,7 +244,7 @@ class TestAdHocCache:
             cache.add_chunk(H(1), b'5678', Statistics(), overwrite=True)
 
     def test_seen_chunk_add_chunk_size(self, cache):
-        assert cache.add_chunk(H(1), b'5678', Statistics()) == (H(1), 4, 0)
+        assert cache.add_chunk(H(1), b'5678', Statistics()) == (H(1), 4)
 
     def test_deletes_chunks_during_lifetime(self, cache, repository):
         """E.g. checkpoint archives"""
@@ -270,10 +270,10 @@ class TestAdHocCache:
         assert not hasattr(cache, 'chunks')
 
     def test_incref_after_add_chunk(self, cache):
-        assert cache.add_chunk(H(3), b'5678', Statistics()) == (H(3), 4, 47)
-        assert cache.chunk_incref(H(3), Statistics()) == (H(3), 4, 47)
+        assert cache.add_chunk(H(3), b'5678', Statistics()) == (H(3), 4)
+        assert cache.chunk_incref(H(3), Statistics()) == (H(3), 4)
 
     def test_existing_incref_after_add_chunk(self, cache):
         """This case occurs with part files, see Archive.chunk_file."""
-        assert cache.add_chunk(H(1), b'5678', Statistics()) == (H(1), 4, 0)
-        assert cache.chunk_incref(H(1), Statistics()) == (H(1), 4, 0)
+        assert cache.add_chunk(H(1), b'5678', Statistics()) == (H(1), 4)
+        assert cache.chunk_incref(H(1), Statistics()) == (H(1), 4)
diff --git a/src/borg/testsuite/item.py b/src/borg/testsuite/item.py
index dc171afa5..47f8e1021 100644
--- a/src/borg/testsuite/item.py
+++ b/src/borg/testsuite/item.py
@@ -143,11 +143,10 @@ def test_unknown_property():
 
 def test_item_file_size():
     item = Item(mode=0o100666, chunks=[
-        ChunkListEntry(csize=0, size=1000, id=None),
-        ChunkListEntry(csize=0, size=2000, id=None),
+        ChunkListEntry(size=1000, id=None),
+        ChunkListEntry(size=2000, id=None),
     ])
     assert item.get_size() == 3000
-    assert item.get_size(compressed=True) == 0  # no csize any more
     item.get_size(memorize=True)
     assert item.size == 3000
 

From b726aa5665eaf57965bbcff99a9fe3e1a912a6a3 Mon Sep 17 00:00:00 2001
From: Thomas Waldmann <tw@waldmann-edv.de>
Date: Fri, 10 Jun 2022 20:54:57 +0200
Subject: [PATCH 031/160] remove csize support from get_size

---
 src/borg/archive.py             | 2 +-
 src/borg/helpers/parseformat.py | 2 +-
 src/borg/item.pyx               | 9 ++-------
 3 files changed, 4 insertions(+), 9 deletions(-)

diff --git a/src/borg/archive.py b/src/borg/archive.py
index 8992f42d3..710a51d31 100644
--- a/src/borg/archive.py
+++ b/src/borg/archive.py
@@ -1805,7 +1805,7 @@ class ArchiveChecker:
             item.chunks = chunk_list
             if 'size' in item:
                 item_size = item.size
-                item_chunks_size = item.get_size(compressed=False, from_chunks=True)
+                item_chunks_size = item.get_size(from_chunks=True)
                 if item_size != item_chunks_size:
                     # just warn, but keep the inconsistency, so that borg extract can warn about it.
                     logger.warning('{}: {}: size inconsistency detected: size {}, chunks size {}'.format(
diff --git a/src/borg/helpers/parseformat.py b/src/borg/helpers/parseformat.py
index dc19590ce..9b57baebb 100644
--- a/src/borg/helpers/parseformat.py
+++ b/src/borg/helpers/parseformat.py
@@ -840,7 +840,7 @@ class ItemFormatter(BaseFormatter):
 
     def calculate_size(self, item):
         # note: does not support hardlink slaves, they will be size 0
-        return item.get_size(compressed=False)
+        return item.get_size()
 
     def hash_item(self, hash_function, item):
         if 'chunks' not in item:
diff --git a/src/borg/item.pyx b/src/borg/item.pyx
index 3897d2d4e..0d4c6ba70 100644
--- a/src/borg/item.pyx
+++ b/src/borg/item.pyx
@@ -284,17 +284,14 @@ class Item(PropDict):
 
     part = PropDict._make_property('part', int)
 
-    def get_size(self, memorize=False, compressed=False, from_chunks=False, consider_ids=None):
+    def get_size(self, *, memorize=False, from_chunks=False, consider_ids=None):
         """
-        Determine the (uncompressed or compressed) size of this item.
+        Determine the uncompressed size of this item.
 
         :param memorize: Whether the computed size value will be stored into the item.
-        :param compressed: Whether the compressed or uncompressed size will be returned.
         :param from_chunks: If true, size is computed from chunks even if a precomputed value is available.
         :param consider_ids: Returns the size of the given ids only.
         """
-        if compressed:
-            return 0  # try to live without csize
         attr = 'size'
         assert not (consider_ids is not None and memorize), "Can't store size when considering only certain ids"
         try:
@@ -497,10 +494,8 @@ class ArchiveItem(PropDict):
     recreate_args = PropDict._make_property('recreate_args', list)  # list of s-e-str
     recreate_partial_chunks = PropDict._make_property('recreate_partial_chunks', list)  # list of tuples
     size = PropDict._make_property('size', int)
-    csize = PropDict._make_property('csize', int)
     nfiles = PropDict._make_property('nfiles', int)
     size_parts = PropDict._make_property('size_parts', int)
-    csize_parts = PropDict._make_property('csize_parts', int)
     nfiles_parts = PropDict._make_property('nfiles_parts', int)
 
     def update_internal(self, d):

From 0211948cacad12b3bdc8e6ab2f1ae2b093fc7e90 Mon Sep 17 00:00:00 2001
From: Thomas Waldmann <tw@waldmann-edv.de>
Date: Fri, 10 Jun 2022 20:58:33 +0200
Subject: [PATCH 032/160] remove csize from summarize return tuple

---
 src/borg/cache.py               | 2 +-
 src/borg/hashindex.pyx          | 4 ++--
 src/borg/testsuite/hashindex.py | 2 +-
 3 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/borg/cache.py b/src/borg/cache.py
index 59b50837a..618a61925 100644
--- a/src/borg/cache.py
+++ b/src/borg/cache.py
@@ -423,7 +423,7 @@ Chunk index:    {0.total_unique_chunks:20d} {0.total_chunks:20d}"""
     def stats(self):
         from .archive import Archive
         # XXX: this should really be moved down to `hashindex.pyx`
-        total_size, _, unique_size, _, total_unique_chunks, total_chunks = self.chunks.summarize()
+        total_size, unique_size, total_unique_chunks, total_chunks = self.chunks.summarize()
         # the above values have the problem that they do not consider part files,
         # thus the total_size might be too high (chunks referenced
         # by the part files AND by the complete file).
diff --git a/src/borg/hashindex.pyx b/src/borg/hashindex.pyx
index 6ef3a6d55..9720a0a49 100644
--- a/src/borg/hashindex.pyx
+++ b/src/borg/hashindex.pyx
@@ -358,7 +358,7 @@ cdef class ChunkIndex(IndexBase):
         return iter
 
     def summarize(self):
-        cdef uint64_t size = 0, csize = 0, unique_size = 0, unique_csize = 0, chunks = 0, unique_chunks = 0
+        cdef uint64_t size = 0, unique_size = 0, chunks = 0, unique_chunks = 0
         cdef uint32_t *values
         cdef uint32_t refcount
         cdef unsigned char *key = NULL
@@ -375,7 +375,7 @@ cdef class ChunkIndex(IndexBase):
             unique_size += _le32toh(values[1])
             size += <uint64_t> _le32toh(values[1]) * _le32toh(values[0])
 
-        return size, csize, unique_size, unique_csize, unique_chunks, chunks
+        return size, unique_size, unique_chunks, chunks
 
     def stats_against(self, ChunkIndex master_index):
         """
diff --git a/src/borg/testsuite/hashindex.py b/src/borg/testsuite/hashindex.py
index f16706ca9..a96c76a6a 100644
--- a/src/borg/testsuite/hashindex.py
+++ b/src/borg/testsuite/hashindex.py
@@ -147,7 +147,7 @@ class HashIndexTestCase(BaseTestCase):
         idx[H(2)] = 2, 2000, 200
         idx[H(3)] = 3, 3000, 300
 
-        size, _, unique_size, _, unique_chunks, chunks = idx.summarize()
+        size, unique_size, unique_chunks, chunks = idx.summarize()
         assert size == 1000 + 2 * 2000 + 3 * 3000
         assert unique_size == 1000 + 2000 + 3000
         assert chunks == 1 + 2 + 3

From b82a39c3b3e204d23407fb73e3c2813adbf49e78 Mon Sep 17 00:00:00 2001
From: Thomas Waldmann <tw@waldmann-edv.de>
Date: Fri, 10 Jun 2022 21:07:09 +0200
Subject: [PATCH 033/160] remove csize from stats_against()

---
 src/borg/hashindex.pyx | 9 +++------
 1 file changed, 3 insertions(+), 6 deletions(-)

diff --git a/src/borg/hashindex.pyx b/src/borg/hashindex.pyx
index 9720a0a49..1b978c66f 100644
--- a/src/borg/hashindex.pyx
+++ b/src/borg/hashindex.pyx
@@ -387,9 +387,9 @@ cdef class ChunkIndex(IndexBase):
         This index must be a subset of *master_index*.
 
         Return the same statistics tuple as summarize:
-        size, csize, unique_size, unique_csize, unique_chunks, chunks.
+        size, unique_size, unique_chunks, chunks.
         """
-        cdef uint64_t size = 0, csize = 0, unique_size = 0, unique_csize = 0, chunks = 0, unique_chunks = 0
+        cdef uint64_t size = 0, unique_size = 0, chunks = 0, unique_chunks = 0
         cdef uint32_t our_refcount, chunk_size, chunk_csize
         cdef const uint32_t *our_values
         cdef const uint32_t *master_values
@@ -406,18 +406,15 @@ cdef class ChunkIndex(IndexBase):
                 raise ValueError('stats_against: key contained in self but not in master_index.')
             our_refcount = _le32toh(our_values[0])
             chunk_size = _le32toh(master_values[1])
-            chunk_csize = _le32toh(master_values[2])
 
             chunks += our_refcount
             size += <uint64_t> chunk_size * our_refcount
-            csize += <uint64_t> chunk_csize * our_refcount
             if our_values[0] == master_values[0]:
                 # our refcount equals the master's refcount, so this chunk is unique to us
                 unique_chunks += 1
                 unique_size += chunk_size
-                unique_csize += chunk_csize
 
-        return size, csize, unique_size, unique_csize, unique_chunks, chunks
+        return size, unique_size, unique_chunks, chunks
 
     def add(self, key, refs, size, csize):
         assert len(key) == self.key_size

From 2c1f7951c45942a3355533b7bc545d3b87e448f9 Mon Sep 17 00:00:00 2001
From: Thomas Waldmann <tw@waldmann-edv.de>
Date: Fri, 10 Jun 2022 22:23:27 +0200
Subject: [PATCH 034/160] remove csize from ChunkIndexEntry

---
 src/borg/archive.py             |  14 ++--
 src/borg/cache.py               |  24 ++++---
 src/borg/cache_sync/unpack.h    |   1 -
 src/borg/hashindex.pyx          |  45 ++++---------
 src/borg/testsuite/archiver.py  |   6 +-
 src/borg/testsuite/cache.py     |  16 ++---
 src/borg/testsuite/hashindex.py | 111 ++++++++++++++++----------------
 7 files changed, 100 insertions(+), 117 deletions(-)

diff --git a/src/borg/archive.py b/src/borg/archive.py
index 710a51d31..6fe1db9f3 100644
--- a/src/borg/archive.py
+++ b/src/borg/archive.py
@@ -483,6 +483,10 @@ class Archive:
     def duration_from_meta(self):
         return format_timedelta(self.ts_end - self.ts)
 
+    def _archive_csize(self):
+        cdata = self.repository.get(self.id)
+        return len(cdata)
+
     def info(self):
         if self.create:
             stats = self.stats
@@ -500,7 +504,7 @@ class Archive:
             'duration': (end - start).total_seconds(),
             'stats': stats.as_dict(),
             'limits': {
-                'max_archive_size': self.cache.chunks[self.id].csize / MAX_DATA_SIZE,
+                'max_archive_size': self._archive_csize() / MAX_DATA_SIZE,
             },
         }
         if self.create:
@@ -529,7 +533,7 @@ Utilization of max. archive size: {csize_max:.0%}
             self,
             start=OutputTimestamp(self.start.replace(tzinfo=timezone.utc)),
             end=OutputTimestamp(self.end.replace(tzinfo=timezone.utc)),
-            csize_max=self.cache.chunks[self.id].csize / MAX_DATA_SIZE,
+            csize_max=self._archive_csize() / MAX_DATA_SIZE,
             location=self.repository._location.canonical_path()
 )
 
@@ -1561,7 +1565,7 @@ class ArchiveChecker:
             if not result:
                 break
             marker = result[-1]
-            init_entry = ChunkIndexEntry(refcount=0, size=0, csize=0)
+            init_entry = ChunkIndexEntry(refcount=0, size=0)
             for id_ in result:
                 self.chunks[id_] = init_entry
 
@@ -1718,7 +1722,7 @@ class ArchiveChecker:
         self.chunks.pop(Manifest.MANIFEST_ID, None)
 
         def mark_as_possibly_superseded(id_):
-            if self.chunks.get(id_, ChunkIndexEntry(0, 0, 0)).refcount == 0:
+            if self.chunks.get(id_, ChunkIndexEntry(0, 0)).refcount == 0:
                 self.possibly_superseded.add(id_)
 
         def add_callback(chunk):
@@ -1732,7 +1736,7 @@ class ArchiveChecker:
                 self.chunks.incref(id_)
             except KeyError:
                 assert cdata is not None
-                self.chunks[id_] = ChunkIndexEntry(refcount=1, size=size, csize=0)  # was: csize=csize
+                self.chunks[id_] = ChunkIndexEntry(refcount=1, size=size)
                 if self.repair:
                     self.repository.put(id_, cdata)
 
diff --git a/src/borg/cache.py b/src/borg/cache.py
index 618a61925..ac5c90744 100644
--- a/src/borg/cache.py
+++ b/src/borg/cache.py
@@ -713,13 +713,13 @@ class LocalCache(CacheStatsMixin):
             nonlocal processed_item_metadata_bytes
             nonlocal processed_item_metadata_chunks
             csize, data = decrypted_repository.get(archive_id)
-            chunk_idx.add(archive_id, 1, len(data), csize)
+            chunk_idx.add(archive_id, 1, len(data))
             archive = ArchiveItem(internal_dict=msgpack.unpackb(data))
             if archive.version not in (1, 2):  # legacy
                 raise Exception('Unknown archive metadata version')
             sync = CacheSynchronizer(chunk_idx)
             for item_id, (csize, data) in zip(archive.items, decrypted_repository.get_many(archive.items)):
-                chunk_idx.add(item_id, 1, len(data), csize)
+                chunk_idx.add(item_id, 1, len(data))
                 processed_item_metadata_bytes += len(data)
                 processed_item_metadata_chunks += 1
                 sync.feed(data)
@@ -903,14 +903,13 @@ class LocalCache(CacheStatsMixin):
         if size is None:
             raise ValueError("when giving compressed data for a new chunk, the uncompressed size must be given also")
         data = self.key.encrypt(id, chunk, compress=compress)
-        csize = 0  # len(data)
         self.repository.put(id, data, wait=wait)
-        self.chunks.add(id, 1, size, csize)
+        self.chunks.add(id, 1, size)
         stats.update(size)
         return ChunkListEntry(id, size)
 
     def seen_chunk(self, id, size=None):
-        refcount, stored_size, _ = self.chunks.get(id, ChunkIndexEntry(0, None, None))
+        refcount, stored_size = self.chunks.get(id, ChunkIndexEntry(0, None))
         if size is not None and stored_size is not None and size != stored_size:
             # we already have a chunk with that id, but different size.
             # this is either a hash collision (unlikely) or corruption or a bug.
@@ -921,14 +920,14 @@ class LocalCache(CacheStatsMixin):
     def chunk_incref(self, id, stats, size=None, part=False):
         if not self.txn_active:
             self.begin_txn()
-        count, _size, _ = self.chunks.incref(id)
+        count, _size = self.chunks.incref(id)
         stats.update(_size, part=part)
         return ChunkListEntry(id, _size)
 
     def chunk_decref(self, id, stats, wait=True, part=False):
         if not self.txn_active:
             self.begin_txn()
-        count, size, _ = self.chunks.decref(id)
+        count, size = self.chunks.decref(id)
         if count == 0:
             del self.chunks[id]
             self.repository.delete(id, wait=wait)
@@ -1071,16 +1070,15 @@ Chunk index:    {0.total_unique_chunks:20d}             unknown"""
         if refcount:
             return self.chunk_incref(id, stats, size=size)
         data = self.key.encrypt(id, chunk, compress=compress)
-        csize = len(data)
         self.repository.put(id, data, wait=wait)
-        self.chunks.add(id, 1, size, csize)
+        self.chunks.add(id, 1, size)
         stats.update(size)
         return ChunkListEntry(id, size)
 
     def seen_chunk(self, id, size=None):
         if not self._txn_active:
             self.begin_txn()
-        entry = self.chunks.get(id, ChunkIndexEntry(0, None, None))
+        entry = self.chunks.get(id, ChunkIndexEntry(0, None))
         if entry.refcount and size and not entry.size:
             # The LocalCache has existing size information and uses *size* to make an effort at detecting collisions.
             # This is of course not possible for the AdHocCache.
@@ -1091,7 +1089,7 @@ Chunk index:    {0.total_unique_chunks:20d}             unknown"""
     def chunk_incref(self, id, stats, size=None, part=False):
         if not self._txn_active:
             self.begin_txn()
-        count, _size, csize = self.chunks.incref(id)
+        count, _size = self.chunks.incref(id)
         # When _size is 0 and size is not given, then this chunk has not been locally visited yet (seen_chunk with
         # size or add_chunk); we can't add references to those (size=0 is invalid) and generally don't try to.
         size = _size or size
@@ -1102,7 +1100,7 @@ Chunk index:    {0.total_unique_chunks:20d}             unknown"""
     def chunk_decref(self, id, stats, wait=True, part=False):
         if not self._txn_active:
             self.begin_txn()
-        count, size, csize = self.chunks.decref(id)
+        count, size = self.chunks.decref(id)
         if count == 0:
             del self.chunks[id]
             self.repository.delete(id, wait=wait)
@@ -1142,7 +1140,7 @@ Chunk index:    {0.total_unique_chunks:20d}             unknown"""
             # All chunks from the repository have a refcount of MAX_VALUE, which is sticky,
             # therefore we can't/won't delete them. Chunks we added ourselves in this transaction
             # (e.g. checkpoint archives) are tracked correctly.
-            init_entry = ChunkIndexEntry(refcount=ChunkIndex.MAX_VALUE, size=0, csize=0)
+            init_entry = ChunkIndexEntry(refcount=ChunkIndex.MAX_VALUE, size=0)
             for id_ in result:
                 self.chunks[id_] = init_entry
         assert len(self.chunks) == num_chunks
diff --git a/src/borg/cache_sync/unpack.h b/src/borg/cache_sync/unpack.h
index 73f86d7bd..a04e81147 100644
--- a/src/borg/cache_sync/unpack.h
+++ b/src/borg/cache_sync/unpack.h
@@ -279,7 +279,6 @@ static inline int unpack_callback_array_end(unpack_user* u)
             /* refcount, size */
             cache_values[0] = _htole32(1);
             cache_values[1] = _htole32(u->current.size);
-            cache_values[2] = _htole32(0);  /* fake csize for now */
             if(!hashindex_set(u->chunks, u->current.key, cache_values)) {
                 SET_LAST_ERROR("hashindex_set failed");
                 return -1;
diff --git a/src/borg/hashindex.pyx b/src/borg/hashindex.pyx
index 1b978c66f..4b9fe316c 100644
--- a/src/borg/hashindex.pyx
+++ b/src/borg/hashindex.pyx
@@ -269,12 +269,12 @@ cdef class NSKeyIterator:
         return (<char *>self.key)[:self.key_size], (segment, _le32toh(value[1]))
 
 
-ChunkIndexEntry = namedtuple('ChunkIndexEntry', 'refcount size csize')
+ChunkIndexEntry = namedtuple('ChunkIndexEntry', 'refcount size')
 
 
 cdef class ChunkIndex(IndexBase):
     """
-    Mapping of 32 byte keys to (refcount, size, csize), which are all 32-bit unsigned.
+    Mapping of 32 byte keys to (refcount, size), which are all 32-bit unsigned.
 
     The reference count cannot overflow. If an overflow would occur, the refcount
     is fixed to MAX_VALUE and will neither increase nor decrease by incref(), decref()
@@ -289,7 +289,7 @@ cdef class ChunkIndex(IndexBase):
     Assigning refcounts in this reserved range is an invalid operation and raises AssertionError.
     """
 
-    value_size = 12
+    value_size = 8
 
     def __getitem__(self, key):
         assert len(key) == self.key_size
@@ -298,16 +298,15 @@ cdef class ChunkIndex(IndexBase):
             raise KeyError(key)
         cdef uint32_t refcount = _le32toh(data[0])
         assert refcount <= _MAX_VALUE, "invalid reference count"
-        return ChunkIndexEntry(refcount, _le32toh(data[1]), _le32toh(data[2]))
+        return ChunkIndexEntry(refcount, _le32toh(data[1]))
 
     def __setitem__(self, key, value):
         assert len(key) == self.key_size
-        cdef uint32_t[3] data
+        cdef uint32_t[2] data
         cdef uint32_t refcount = value[0]
         assert refcount <= _MAX_VALUE, "invalid reference count"
         data[0] = _htole32(refcount)
         data[1] = _htole32(value[1])
-        data[2] = _htole32(value[2])
         if not hashindex_set(self.index, <unsigned char *>key, data):
             raise Exception('hashindex_set failed')
 
@@ -319,7 +318,7 @@ cdef class ChunkIndex(IndexBase):
         return data != NULL
 
     def incref(self, key):
-        """Increase refcount for 'key', return (refcount, size, csize)"""
+        """Increase refcount for 'key', return (refcount, size)"""
         assert len(key) == self.key_size
         data = <uint32_t *>hashindex_get(self.index, <unsigned char *>key)
         if not data:
@@ -329,10 +328,10 @@ cdef class ChunkIndex(IndexBase):
         if refcount != _MAX_VALUE:
             refcount += 1
         data[0] = _htole32(refcount)
-        return refcount, _le32toh(data[1]), _le32toh(data[2])
+        return refcount, _le32toh(data[1])
 
     def decref(self, key):
-        """Decrease refcount for 'key', return (refcount, size, csize)"""
+        """Decrease refcount for 'key', return (refcount, size)"""
         assert len(key) == self.key_size
         data = <uint32_t *>hashindex_get(self.index, <unsigned char *>key)
         if not data:
@@ -343,7 +342,7 @@ cdef class ChunkIndex(IndexBase):
         if refcount != _MAX_VALUE:
             refcount -= 1
         data[0] = _htole32(refcount)
-        return refcount, _le32toh(data[1]), _le32toh(data[2])
+        return refcount, _le32toh(data[1])
 
     def iteritems(self, marker=None):
         cdef const unsigned char *key
@@ -390,7 +389,7 @@ cdef class ChunkIndex(IndexBase):
         size, unique_size, unique_chunks, chunks.
         """
         cdef uint64_t size = 0, unique_size = 0, chunks = 0, unique_chunks = 0
-        cdef uint32_t our_refcount, chunk_size, chunk_csize
+        cdef uint32_t our_refcount, chunk_size
         cdef const uint32_t *our_values
         cdef const uint32_t *master_values
         cdef const unsigned char *key = NULL
@@ -416,12 +415,11 @@ cdef class ChunkIndex(IndexBase):
 
         return size, unique_size, unique_chunks, chunks
 
-    def add(self, key, refs, size, csize):
+    def add(self, key, refs, size):
         assert len(key) == self.key_size
-        cdef uint32_t[3] data
+        cdef uint32_t[2] data
         data[0] = _htole32(refs)
         data[1] = _htole32(size)
-        data[2] = _htole32(csize)
         self._add(<unsigned char*> key, data)
 
     cdef _add(self, unsigned char *key, uint32_t *data):
@@ -435,7 +433,6 @@ cdef class ChunkIndex(IndexBase):
             result64 = refcount1 + refcount2
             values[0] = _htole32(min(result64, _MAX_VALUE))
             values[1] = data[1]
-            values[2] = data[2]
         else:
             if not hashindex_set(self.index, key, data):
                 raise Exception('hashindex_set failed')
@@ -449,22 +446,6 @@ cdef class ChunkIndex(IndexBase):
                 break
             self._add(key, <uint32_t*> (key + self.key_size))
 
-    def zero_csize_ids(self):
-        cdef unsigned char *key = NULL
-        cdef uint32_t *values
-        entries = []
-        while True:
-            key = hashindex_next_key(self.index, key)
-            if not key:
-                break
-            values = <uint32_t*> (key + self.key_size)
-            refcount = _le32toh(values[0])
-            assert refcount <= _MAX_VALUE, "invalid reference count"
-            if _le32toh(values[2]) == 0:
-                # csize == 0
-                entries.append(PyBytes_FromStringAndSize(<char*> key, self.key_size))
-        return entries
-
 
 cdef class ChunkKeyIterator:
     cdef ChunkIndex idx
@@ -491,7 +472,7 @@ cdef class ChunkKeyIterator:
         cdef uint32_t *value = <uint32_t *>(self.key + self.key_size)
         cdef uint32_t refcount = _le32toh(value[0])
         assert refcount <= _MAX_VALUE, "invalid reference count"
-        return (<char *>self.key)[:self.key_size], ChunkIndexEntry(refcount, _le32toh(value[1]), _le32toh(value[2]))
+        return (<char *>self.key)[:self.key_size], ChunkIndexEntry(refcount, _le32toh(value[1]))
 
 
 cdef Py_buffer ro_buffer(object data) except *:
diff --git a/src/borg/testsuite/archiver.py b/src/borg/testsuite/archiver.py
index 4789f8e47..e033d6cf7 100644
--- a/src/borg/testsuite/archiver.py
+++ b/src/borg/testsuite/archiver.py
@@ -2885,12 +2885,12 @@ class ArchiverTestCase(ArchiverTestCaseBase):
                 correct_chunks = cache.chunks
         assert original_chunks is not correct_chunks
         seen = set()
-        for id, (refcount, size, _) in correct_chunks.iteritems():
-            o_refcount, o_size, _ = original_chunks[id]
+        for id, (refcount, size) in correct_chunks.iteritems():
+            o_refcount, o_size = original_chunks[id]
             assert refcount == o_refcount
             assert size == o_size
             seen.add(id)
-        for id, (refcount, size, _) in original_chunks.iteritems():
+        for id, (refcount, size) in original_chunks.iteritems():
             assert id in seen
 
     def test_check_cache(self):
diff --git a/src/borg/testsuite/cache.py b/src/borg/testsuite/cache.py
index d476492d8..faff9f2b7 100644
--- a/src/borg/testsuite/cache.py
+++ b/src/borg/testsuite/cache.py
@@ -49,8 +49,8 @@ class TestCacheSynchronizer:
         })
         sync.feed(data)
         assert len(index) == 2
-        assert index[H(1)] == (1, 1, 0)
-        assert index[H(2)] == (1, 2, 0)
+        assert index[H(1)] == (1, 1)
+        assert index[H(2)] == (1, 2)
 
     def test_multiple(self, index, sync):
         data = packb({
@@ -103,9 +103,9 @@ class TestCacheSynchronizer:
         sync.feed(part2)
         sync.feed(part3)
         assert len(index) == 3
-        assert index[H(1)] == (3, 1, 0)
-        assert index[H(2)] == (2, 2, 0)
-        assert index[H(3)] == (1, 1, 0)
+        assert index[H(1)] == (3, 1)
+        assert index[H(2)] == (2, 2)
+        assert index[H(3)] == (1, 1)
 
     @pytest.mark.parametrize('elem,error', (
         ({1: 2}, 'Unexpected object: map'),
@@ -189,7 +189,7 @@ class TestCacheSynchronizer:
             ]
         })
         sync.feed(data)
-        assert index[H(0)] == (ChunkIndex.MAX_VALUE, 1234, 5678)
+        assert index[H(0)] == (ChunkIndex.MAX_VALUE, 1234)
 
     def test_refcount_one_below_max_value(self):
         index = self.make_index_with_refcount(ChunkIndex.MAX_VALUE - 1)
@@ -201,9 +201,9 @@ class TestCacheSynchronizer:
         })
         sync.feed(data)
         # Incremented to maximum
-        assert index[H(0)] == (ChunkIndex.MAX_VALUE, 1234, 5678)
+        assert index[H(0)] == (ChunkIndex.MAX_VALUE, 1234)
         sync.feed(data)
-        assert index[H(0)] == (ChunkIndex.MAX_VALUE, 1234, 5678)
+        assert index[H(0)] == (ChunkIndex.MAX_VALUE, 1234)
 
 
 class TestAdHocCache:
diff --git a/src/borg/testsuite/hashindex.py b/src/borg/testsuite/hashindex.py
index a96c76a6a..7a3b53e33 100644
--- a/src/borg/testsuite/hashindex.py
+++ b/src/borg/testsuite/hashindex.py
@@ -91,8 +91,8 @@ class HashIndexTestCase(BaseTestCase):
                            '85f72b036c692c8266e4f51ccf0cff2147204282b5e316ae508d30a448d88fef')
 
     def test_chunkindex(self):
-        self._generic_test(ChunkIndex, lambda x: (x, x, x),
-                           'c83fdf33755fc37879285f2ecfc5d1f63b97577494902126b6fb6f3e4d852488')
+        self._generic_test(ChunkIndex, lambda x: (x, x),
+                           '85f72b036c692c8266e4f51ccf0cff2147204282b5e316ae508d30a448d88fef')
 
     def test_resize(self):
         n = 2000  # Must be >= MIN_BUCKETS
@@ -126,26 +126,26 @@ class HashIndexTestCase(BaseTestCase):
 
     def test_chunkindex_merge(self):
         idx1 = ChunkIndex()
-        idx1[H(1)] = 1, 100, 100
-        idx1[H(2)] = 2, 200, 200
-        idx1[H(3)] = 3, 300, 300
+        idx1[H(1)] = 1, 100
+        idx1[H(2)] = 2, 200
+        idx1[H(3)] = 3, 300
         # no H(4) entry
         idx2 = ChunkIndex()
-        idx2[H(1)] = 4, 100, 100
-        idx2[H(2)] = 5, 200, 200
+        idx2[H(1)] = 4, 100
+        idx2[H(2)] = 5, 200
         # no H(3) entry
-        idx2[H(4)] = 6, 400, 400
+        idx2[H(4)] = 6, 400
         idx1.merge(idx2)
-        assert idx1[H(1)] == (5, 100, 100)
-        assert idx1[H(2)] == (7, 200, 200)
-        assert idx1[H(3)] == (3, 300, 300)
-        assert idx1[H(4)] == (6, 400, 400)
+        assert idx1[H(1)] == (5, 100)
+        assert idx1[H(2)] == (7, 200)
+        assert idx1[H(3)] == (3, 300)
+        assert idx1[H(4)] == (6, 400)
 
     def test_chunkindex_summarize(self):
         idx = ChunkIndex()
-        idx[H(1)] = 1, 1000, 100
-        idx[H(2)] = 2, 2000, 200
-        idx[H(3)] = 3, 3000, 300
+        idx[H(1)] = 1, 1000
+        idx[H(2)] = 2, 2000
+        idx[H(3)] = 3, 3000
 
         size, unique_size, unique_chunks, chunks = idx.summarize()
         assert size == 1000 + 2 * 2000 + 3 * 3000
@@ -167,14 +167,14 @@ class HashIndexExtraTestCase(BaseTestCase):
         keys, to_delete_keys = all_keys[0:(2*key_count//3)], all_keys[(2*key_count//3):]
 
         for i, key in enumerate(keys):
-            index[key] = (i, i, i)
+            index[key] = (i, i)
         for i, key in enumerate(to_delete_keys):
-            index[key] = (i, i, i)
+            index[key] = (i, i)
 
         for key in to_delete_keys:
             del index[key]
         for i, key in enumerate(keys):
-            assert index[key] == (i, i, i)
+            assert index[key] == (i, i)
         for key in to_delete_keys:
             assert index.get(key) is None
 
@@ -188,12 +188,12 @@ class HashIndexExtraTestCase(BaseTestCase):
 class HashIndexSizeTestCase(BaseTestCase):
     def test_size_on_disk(self):
         idx = ChunkIndex()
-        assert idx.size() == 18 + 1031 * (32 + 3 * 4)
+        assert idx.size() == 18 + 1031 * (32 + 2 * 4)
 
     def test_size_on_disk_accurate(self):
         idx = ChunkIndex()
         for i in range(1234):
-            idx[H(i)] = i, i**2, i**3
+            idx[H(i)] = i, i**2
         with tempfile.NamedTemporaryFile() as file:
             idx.write(file.name)
             size = os.path.getsize(file.name)
@@ -203,7 +203,7 @@ class HashIndexSizeTestCase(BaseTestCase):
 class HashIndexRefcountingTestCase(BaseTestCase):
     def test_chunkindex_limit(self):
         idx = ChunkIndex()
-        idx[H(1)] = ChunkIndex.MAX_VALUE - 1, 1, 2
+        idx[H(1)] = ChunkIndex.MAX_VALUE - 1, 1
 
         # 5 is arbitrary, any number of incref/decrefs shouldn't move it once it's limited
         for i in range(5):
@@ -217,9 +217,9 @@ class HashIndexRefcountingTestCase(BaseTestCase):
     def _merge(self, refcounta, refcountb):
         def merge(refcount1, refcount2):
             idx1 = ChunkIndex()
-            idx1[H(1)] = refcount1, 1, 2
+            idx1[H(1)] = refcount1, 1
             idx2 = ChunkIndex()
-            idx2[H(1)] = refcount2, 1, 2
+            idx2[H(1)] = refcount2, 1
             idx1.merge(idx2)
             refcount, *_ = idx1[H(1)]
             return refcount
@@ -251,44 +251,44 @@ class HashIndexRefcountingTestCase(BaseTestCase):
 
     def test_chunkindex_add(self):
         idx1 = ChunkIndex()
-        idx1.add(H(1), 5, 6, 7)
-        assert idx1[H(1)] == (5, 6, 7)
-        idx1.add(H(1), 1, 2, 3)
-        assert idx1[H(1)] == (6, 2, 3)
+        idx1.add(H(1), 5, 6)
+        assert idx1[H(1)] == (5, 6)
+        idx1.add(H(1), 1, 2)
+        assert idx1[H(1)] == (6, 2)
 
     def test_incref_limit(self):
         idx1 = ChunkIndex()
-        idx1[H(1)] = (ChunkIndex.MAX_VALUE, 6, 7)
+        idx1[H(1)] = ChunkIndex.MAX_VALUE, 6
         idx1.incref(H(1))
         refcount, *_ = idx1[H(1)]
         assert refcount == ChunkIndex.MAX_VALUE
 
     def test_decref_limit(self):
         idx1 = ChunkIndex()
-        idx1[H(1)] = ChunkIndex.MAX_VALUE, 6, 7
+        idx1[H(1)] = ChunkIndex.MAX_VALUE, 6
         idx1.decref(H(1))
         refcount, *_ = idx1[H(1)]
         assert refcount == ChunkIndex.MAX_VALUE
 
     def test_decref_zero(self):
         idx1 = ChunkIndex()
-        idx1[H(1)] = 0, 0, 0
+        idx1[H(1)] = 0, 0
         with self.assert_raises(AssertionError):
             idx1.decref(H(1))
 
     def test_incref_decref(self):
         idx1 = ChunkIndex()
-        idx1.add(H(1), 5, 6, 7)
-        assert idx1[H(1)] == (5, 6, 7)
+        idx1.add(H(1), 5, 6)
+        assert idx1[H(1)] == (5, 6)
         idx1.incref(H(1))
-        assert idx1[H(1)] == (6, 6, 7)
+        assert idx1[H(1)] == (6, 6)
         idx1.decref(H(1))
-        assert idx1[H(1)] == (5, 6, 7)
+        assert idx1[H(1)] == (5, 6)
 
     def test_setitem_raises(self):
         idx1 = ChunkIndex()
         with self.assert_raises(AssertionError):
-            idx1[H(1)] = ChunkIndex.MAX_VALUE + 1, 0, 0
+            idx1[H(1)] = ChunkIndex.MAX_VALUE + 1, 0
 
     def test_keyerror(self):
         idx = ChunkIndex()
@@ -299,14 +299,15 @@ class HashIndexRefcountingTestCase(BaseTestCase):
         with self.assert_raises(KeyError):
             idx[H(1)]
         with self.assert_raises(OverflowError):
-            idx.add(H(1), -1, 0, 0)
+            idx.add(H(1), -1, 0)
 
 
 class HashIndexDataTestCase(BaseTestCase):
-    # This bytestring was created with 1.0-maint at c2f9533
-    HASHINDEX = b'eJzt0L0NgmAUhtHLT0LDEI6AuAEhMVYmVnSuYefC7AB3Aj9KNedJbnfyFne6P67P27w0EdG1Eac+Cm1ZybAsy7Isy7Isy7Isy7I' \
-                b'sy7Isy7Isy7Isy7Isy7Isy7Isy7Isy7Isy7Isy7Isy7Isy7Isy7Isy7Isy7Isy7Isy7Isy7Isy7Isy7Isy7Isy7LsL9nhc+cqTZ' \
-                b'3XlO2Ys++Du5fX+l1/YFmWZVmWZVmWZVmWZVmWZVmWZVmWZVmWZVmWZVmWZVmWZVmWZVmWZVmWZVmWZVmWZVn2/+0O2rYccw=='
+    # This bytestring was created with borg2-pre 2022-06-10
+    HASHINDEX = b'eJzt0LEJg1AYhdE/JqBjOEJMNhBBrAQrO9ewc+HsoG+CPMsEz1cfbnHbceqXoZvvEVE+IuoqMu2pnOE4' \
+                b'juM4juM4juM4juM4juM4juM4juM4juM4juM4juM4juM4juM4juM4juM4juM4juM4juM4juM4juM4juM4' \
+                b'juM4juM4juM4jruie36vuSVT5N0rzW0n9t7r5z9+4TiO4ziO4ziO4ziO4ziO4ziO4ziO4ziO4ziO4ziO' \
+                b'4ziO4ziO4ziO4ziO4ziO437LHbSVHGw='
 
     def _serialize_hashindex(self, idx):
         with tempfile.TemporaryDirectory() as tempdir:
@@ -330,23 +331,23 @@ class HashIndexDataTestCase(BaseTestCase):
 
     def test_identical_creation(self):
         idx1 = ChunkIndex()
-        idx1[H(1)] = 1, 2, 3
-        idx1[H(2)] = 2**31 - 1, 0, 0
-        idx1[H(3)] = 4294962296, 0, 0  # 4294962296 is -5000 interpreted as an uint32_t
+        idx1[H(1)] = 1, 2
+        idx1[H(2)] = 2**31 - 1, 0
+        idx1[H(3)] = 4294962296, 0  # 4294962296 is -5000 interpreted as an uint32_t
 
         serialized = self._serialize_hashindex(idx1)
         assert self._unpack(serialized) == self._unpack(self.HASHINDEX)
 
     def test_read_known_good(self):
         idx1 = self._deserialize_hashindex(self.HASHINDEX)
-        assert idx1[H(1)] == (1, 2, 3)
-        assert idx1[H(2)] == (2**31 - 1, 0, 0)
-        assert idx1[H(3)] == (4294962296, 0, 0)
+        assert idx1[H(1)] == (1, 2)
+        assert idx1[H(2)] == (2**31 - 1, 0)
+        assert idx1[H(3)] == (4294962296, 0)
 
         idx2 = ChunkIndex()
-        idx2[H(3)] = 2**32 - 123456, 6, 7
+        idx2[H(3)] = 2**32 - 123456, 6
         idx1.merge(idx2)
-        assert idx1[H(3)] == (ChunkIndex.MAX_VALUE, 6, 7)
+        assert idx1[H(3)] == (ChunkIndex.MAX_VALUE, 6)
 
 
 class HashIndexIntegrityTestCase(HashIndexDataTestCase):
@@ -497,16 +498,16 @@ class HashIndexCompactTestCase(HashIndexDataTestCase):
     def test_merge(self):
         master = ChunkIndex()
         idx1 = ChunkIndex()
-        idx1[H(1)] = 1, 100, 100
-        idx1[H(2)] = 2, 200, 200
-        idx1[H(3)] = 3, 300, 300
+        idx1[H(1)] = 1, 100
+        idx1[H(2)] = 2, 200
+        idx1[H(3)] = 3, 300
         idx1.compact()
-        assert idx1.size() == 18 + 3 * (32 + 3 * 4)
+        assert idx1.size() == 18 + 3 * (32 + 2 * 4)
 
         master.merge(idx1)
-        assert master[H(1)] == (1, 100, 100)
-        assert master[H(2)] == (2, 200, 200)
-        assert master[H(3)] == (3, 300, 300)
+        assert master[H(1)] == (1, 100)
+        assert master[H(2)] == (2, 200)
+        assert master[H(3)] == (3, 300)
 
 
 class NSIndexTestCase(BaseTestCase):

From 1fd571a4d05318f187dbd8490ec2bd9d88c338b8 Mon Sep 17 00:00:00 2001
From: Thomas Waldmann <tw@waldmann-edv.de>
Date: Fri, 10 Jun 2022 22:39:07 +0200
Subject: [PATCH 035/160] fix comments

---
 src/borg/archiver.py | 2 +-
 src/borg/cache.py    | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/borg/archiver.py b/src/borg/archiver.py
index dfc571cf4..8a308e330 100644
--- a/src/borg/archiver.py
+++ b/src/borg/archiver.py
@@ -443,7 +443,7 @@ class Archiver:
                                     chunks.append(chunk_entry)
                                 present_size += size
                         if not dry_run:
-                            item.chunks = chunks  # overwrite! IDs and sizes are same, csizes are likely different
+                            item.chunks = chunks  # TODO: overwrite? IDs and sizes are same.
                             archive.stats.nfiles += 1
                     if not dry_run:
                         archive.add_item(upgrade_item(item))
diff --git a/src/borg/cache.py b/src/borg/cache.py
index ac5c90744..a964fc605 100644
--- a/src/borg/cache.py
+++ b/src/borg/cache.py
@@ -1015,7 +1015,7 @@ class AdHocCache(CacheStatsMixin):
 
     Compared to the standard LocalCache the AdHocCache does not maintain accurate reference count,
     nor does it provide a files cache (which would require persistence). Chunks that were not added
-    during the current AdHocCache lifetime won't have correct size/csize set (0 bytes) and will
+    during the current AdHocCache lifetime won't have correct size set (0 bytes) and will
     have an infinite reference count (MAX_VALUE).
     """
 

From 19dfbe5c5c5a7fe4cd529580bd03d94b4c075bfb Mon Sep 17 00:00:00 2001
From: Thomas Waldmann <tw@waldmann-edv.de>
Date: Sat, 11 Jun 2022 22:29:43 +0200
Subject: [PATCH 036/160] compute the deduplicated size before compression

so we do not need csize for it.
---
 src/borg/archive.py           | 23 +++++++++++++++++------
 src/borg/archiver.py          |  6 +++---
 src/borg/cache.py             | 20 ++++++++++----------
 src/borg/testsuite/archive.py | 18 ++++++++++--------
 4 files changed, 40 insertions(+), 27 deletions(-)

diff --git a/src/borg/archive.py b/src/borg/archive.py
index 6fe1db9f3..945dc5a8a 100644
--- a/src/borg/archive.py
+++ b/src/borg/archive.py
@@ -58,38 +58,45 @@ class Statistics:
     def __init__(self, output_json=False, iec=False):
         self.output_json = output_json
         self.iec = iec
-        self.osize = self.nfiles = 0
-        self.osize_parts = self.nfiles_parts = 0
+        self.osize = self.usize = self.nfiles = 0
+        self.osize_parts = self.usize_parts = self.nfiles_parts = 0
         self.last_progress = 0  # timestamp when last progress was shown
 
-    def update(self, size, part=False):
+    def update(self, size, unique, part=False):
         if not part:
             self.osize += size
+            if unique:
+                self.usize += size
         else:
             self.osize_parts += size
+            if unique:
+                self.usize_parts += size
 
     def __add__(self, other):
         if not isinstance(other, Statistics):
             raise TypeError('can only add Statistics objects')
         stats = Statistics(self.output_json, self.iec)
         stats.osize = self.osize + other.osize
+        stats.usize = self.usize + other.usize
         stats.nfiles = self.nfiles + other.nfiles
         stats.osize_parts = self.osize_parts + other.osize_parts
+        stats.usize_parts = self.usize_parts + other.usize_parts
         stats.nfiles_parts = self.nfiles_parts + other.nfiles_parts
         return stats
 
-    summary = "{label:15} {stats.osize_fmt:>20s}"
+    summary = "{label:15} {stats.osize_fmt:>20s} {stats.usize_fmt:>20s}"
 
     def __str__(self):
         return self.summary.format(stats=self, label='This archive:')
 
     def __repr__(self):
-        return "<{cls} object at {hash:#x} ({self.osize})>".format(
+        return "<{cls} object at {hash:#x} ({self.osize}, {self.usize})>".format(
             cls=type(self).__name__, hash=id(self), self=self)
 
     def as_dict(self):
         return {
             'original_size': FileSize(self.osize, iec=self.iec),
+            'deduplicated_size': FileSize(self.usize, iec=self.iec),
             'nfiles': self.nfiles,
         }
 
@@ -114,6 +121,10 @@ class Statistics:
     def osize_fmt(self):
         return format_file_size(self.osize, iec=self.iec)
 
+    @property
+    def usize_fmt(self):
+        return format_file_size(self.usize, iec=self.iec)
+
     def show_progress(self, item=None, final=False, stream=None, dt=None):
         now = time.monotonic()
         if dt is None or now - self.last_progress > dt:
@@ -134,7 +145,7 @@ class Statistics:
             else:
                 columns, lines = get_terminal_size()
                 if not final:
-                    msg = '{0.osize_fmt} O {0.nfiles} N '.format(self)
+                    msg = '{0.osize_fmt} O {0.usize_fmt} U {0.nfiles} N '.format(self)
                     path = remove_surrogates(item.path) if item else ''
                     space = columns - swidth(msg)
                     if space < 12:
diff --git a/src/borg/archiver.py b/src/borg/archiver.py
index 8a308e330..3814d1262 100644
--- a/src/borg/archiver.py
+++ b/src/borg/archiver.py
@@ -99,7 +99,7 @@ except BaseException:
 assert EXIT_ERROR == 2, "EXIT_ERROR is not 2, as expected - fix assert AND exception handler right above this line."
 
 
-STATS_HEADER = "                       Original size"
+STATS_HEADER = "                       Original size    Deduplicated size"
 
 PURE_PYTHON_MSGPACK_WARNING = "Using a pure-python msgpack! This will result in lower performance."
 
@@ -1797,8 +1797,8 @@ class Archiver:
                 Command line: {command_line}
                 Utilization of maximum supported archive size: {limits[max_archive_size]:.0%}
                 ------------------------------------------------------------------------------
-                                       Original size
-                This archive:   {stats[original_size]:>20s}
+                                       Original size    Deduplicated size
+                This archive:   {stats[original_size]:>20s} {stats[deduplicated_size]:>20s}
                 {cache}
                 """).strip().format(cache=cache, **info))
             if self.exit_code:
diff --git a/src/borg/cache.py b/src/borg/cache.py
index a964fc605..65cbe7712 100644
--- a/src/borg/cache.py
+++ b/src/borg/cache.py
@@ -406,7 +406,7 @@ class Cache:
 
 class CacheStatsMixin:
     str_format = """\
-All archives:   {0.total_size:>20s}
+All archives:   {0.total_size:>20s} {0.unique_size:>20s}
 
                        Unique chunks         Total chunks
 Chunk index:    {0.total_unique_chunks:20d} {0.total_chunks:20d}"""
@@ -440,7 +440,7 @@ Chunk index:    {0.total_unique_chunks:20d} {0.total_chunks:20d}"""
 
     def format_tuple(self):
         stats = self.stats()
-        for field in ['total_size', ]:
+        for field in ['total_size', 'unique_size']:
             stats[field] = format_file_size(stats[field], iec=self.iec)
         return self.Summary(**stats)
 
@@ -905,7 +905,7 @@ class LocalCache(CacheStatsMixin):
         data = self.key.encrypt(id, chunk, compress=compress)
         self.repository.put(id, data, wait=wait)
         self.chunks.add(id, 1, size)
-        stats.update(size)
+        stats.update(size, not refcount)
         return ChunkListEntry(id, size)
 
     def seen_chunk(self, id, size=None):
@@ -921,7 +921,7 @@ class LocalCache(CacheStatsMixin):
         if not self.txn_active:
             self.begin_txn()
         count, _size = self.chunks.incref(id)
-        stats.update(_size, part=part)
+        stats.update(_size, False, part=part)
         return ChunkListEntry(id, _size)
 
     def chunk_decref(self, id, stats, wait=True, part=False):
@@ -931,9 +931,9 @@ class LocalCache(CacheStatsMixin):
         if count == 0:
             del self.chunks[id]
             self.repository.delete(id, wait=wait)
-            stats.update(-size, part=part)
+            stats.update(-size, True, part=part)
         else:
-            stats.update(-size, part=part)
+            stats.update(-size, False, part=part)
 
     def file_known_and_unchanged(self, hashed_path, path_hash, st):
         """
@@ -1072,7 +1072,7 @@ Chunk index:    {0.total_unique_chunks:20d}             unknown"""
         data = self.key.encrypt(id, chunk, compress=compress)
         self.repository.put(id, data, wait=wait)
         self.chunks.add(id, 1, size)
-        stats.update(size)
+        stats.update(size, not refcount)
         return ChunkListEntry(id, size)
 
     def seen_chunk(self, id, size=None):
@@ -1094,7 +1094,7 @@ Chunk index:    {0.total_unique_chunks:20d}             unknown"""
         # size or add_chunk); we can't add references to those (size=0 is invalid) and generally don't try to.
         size = _size or size
         assert size
-        stats.update(size, part=part)
+        stats.update(size, False, part=part)
         return ChunkListEntry(id, size)
 
     def chunk_decref(self, id, stats, wait=True, part=False):
@@ -1104,9 +1104,9 @@ Chunk index:    {0.total_unique_chunks:20d}             unknown"""
         if count == 0:
             del self.chunks[id]
             self.repository.delete(id, wait=wait)
-            stats.update(-size, part=part)
+            stats.update(-size, True, part=part)
         else:
-            stats.update(-size, part=part)
+            stats.update(-size, False, part=part)
 
     def commit(self):
         if not self._txn_active:
diff --git a/src/borg/testsuite/archive.py b/src/borg/testsuite/archive.py
index 38c4aa3d0..6bfb933ab 100644
--- a/src/borg/testsuite/archive.py
+++ b/src/borg/testsuite/archive.py
@@ -19,44 +19,46 @@ from ..platform import uid2user, gid2group
 @pytest.fixture()
 def stats():
     stats = Statistics()
-    stats.update(20)
+    stats.update(20, unique=True)
     return stats
 
 
 def test_stats_basic(stats):
     assert stats.osize == 20
-    stats.update(20)
+    assert stats.usize == 20
+    stats.update(20, unique=False)
     assert stats.osize == 40
+    assert stats.usize == 20
 
 
 def tests_stats_progress(stats, monkeypatch, columns=80):
     monkeypatch.setenv('COLUMNS', str(columns))
     out = StringIO()
     stats.show_progress(stream=out)
-    s = '20 B O 0 N '
+    s = '20 B O 20 B U 0 N '
     buf = ' ' * (columns - len(s))
     assert out.getvalue() == s + buf + "\r"
 
     out = StringIO()
-    stats.update(10 ** 3)
+    stats.update(10 ** 3, unique=False)
     stats.show_progress(item=Item(path='foo'), final=False, stream=out)
-    s = '1.02 kB O 0 N foo'
+    s = '1.02 kB O 20 B U 0 N foo'
     buf = ' ' * (columns - len(s))
     assert out.getvalue() == s + buf + "\r"
     out = StringIO()
     stats.show_progress(item=Item(path='foo'*40), final=False, stream=out)
-    s = '1.02 kB O 0 N foofoofoofoofoofoofoofoofoofoo...foofoofoofoofoofoofoofoofoofoofoo'
+    s = '1.02 kB O 20 B U 0 N foofoofoofoofoofoofoofoofo...foofoofoofoofoofoofoofoofoofoo'
     buf = ' ' * (columns - len(s))
     assert out.getvalue() == s + buf + "\r"
 
 
 def test_stats_format(stats):
     assert str(stats) == """\
-This archive:                   20 B"""
+This archive:                   20 B                 20 B"""
     s = f"{stats.osize_fmt}"
     assert s == "20 B"
     # kind of redundant, but id is variable so we can't match reliably
-    assert repr(stats) == f'<Statistics object at {id(stats):#x} (20)>'
+    assert repr(stats) == f'<Statistics object at {id(stats):#x} (20, 20)>'
 
 
 def test_stats_progress_json(stats):

From 49adb7715763b8e46c0fc4d0c418175248d2bea7 Mon Sep 17 00:00:00 2001
From: Thomas Waldmann <tw@waldmann-edv.de>
Date: Fri, 10 Jun 2022 22:27:11 +0200
Subject: [PATCH 037/160] calc_stats: deduplicated size now, was deduplicated
 csize

also: remove pre12_meta cache
---
 src/borg/archive.py | 33 +++++++++++++++++++++++----------
 src/borg/cache.py   | 12 ------------
 2 files changed, 23 insertions(+), 22 deletions(-)

diff --git a/src/borg/archive.py b/src/borg/archive.py
index 945dc5a8a..f9dd2e486 100644
--- a/src/borg/archive.py
+++ b/src/borg/archive.py
@@ -629,18 +629,31 @@ Utilization of max. archive size: {csize_max:.0%}
         self.cache.commit()
 
     def calc_stats(self, cache, want_unique=True):
-        # caching wrapper around _calc_stats which is rather slow for archives made with borg < 1.2
-        have_borg12_meta = self.metadata.get('nfiles') is not None
-        try:
-            stats = Statistics.from_raw_dict(**cache.pre12_meta[self.fpr])
-        except KeyError:  # not in pre12_meta cache
-            stats = self._calc_stats(cache, want_unique=want_unique)
-            if not have_borg12_meta:
-                cache.pre12_meta[self.fpr] = stats.as_raw_dict()
-        return stats
+        if not want_unique:
+            unique_size = 0
+        else:
+            def add(id):
+                entry = cache.chunks[id]
+                archive_index.add(id, 1, entry.size)
+
+            archive_index = ChunkIndex()
+            sync = CacheSynchronizer(archive_index)
+            add(self.id)
+            # we must escape any % char in the archive name, because we use it in a format string, see #6500
+            arch_name_escd = self.name.replace('%', '%%')
+            pi = ProgressIndicatorPercent(total=len(self.metadata.items),
+                                          msg='Calculating statistics for archive %s ... %%3.0f%%%%' % arch_name_escd,
+                                          msgid='archive.calc_stats')
+            for id, chunk in zip(self.metadata.items, self.repository.get_many(self.metadata.items)):
+                pi.show(increase=1)
+                add(id)
+                data = self.key.decrypt(id, chunk)
+                sync.feed(data)
+            unique_size = archive_index.stats_against(cache.chunks)[1]
+            pi.finish()
 
-    def _calc_stats(self, cache, want_unique=True):
         stats = Statistics(iec=self.iec)
+        stats.usize = unique_size  # the part files use same chunks as the full file
         stats.nfiles = self.metadata.nfiles
         stats.osize = self.metadata.size
         if self.consider_part_files:
diff --git a/src/borg/cache.py b/src/borg/cache.py
index 65cbe7712..784910673 100644
--- a/src/borg/cache.py
+++ b/src/borg/cache.py
@@ -413,7 +413,6 @@ Chunk index:    {0.total_unique_chunks:20d} {0.total_chunks:20d}"""
 
     def __init__(self, iec=False):
         self.iec = iec
-        self.pre12_meta = {}  # here we cache archive metadata for borg < 1.2
 
     def __str__(self):
         return self.str_format.format(self.format_tuple())
@@ -511,8 +510,6 @@ class LocalCache(CacheStatsMixin):
         os.makedirs(os.path.join(self.path, 'chunks.archive.d'))
         with SaveFile(os.path.join(self.path, files_cache_name()), binary=True):
             pass  # empty file
-        with SaveFile(os.path.join(self.path, 'pre12-meta'), binary=False) as fd:
-            json.dump(self.pre12_meta, fd, indent=4)
 
     def _do_open(self):
         self.cache_config.load()
@@ -523,11 +520,6 @@ class LocalCache(CacheStatsMixin):
             self.files = None
         else:
             self._read_files()
-        try:
-            with open(os.path.join(self.path, 'pre12-meta')) as fd:
-                self.pre12_meta = json.load(fd)
-        except (FileNotFoundError, json.JSONDecodeError):
-            pass
 
     def open(self):
         if not os.path.isdir(self.path):
@@ -536,9 +528,6 @@ class LocalCache(CacheStatsMixin):
         self.rollback()
 
     def close(self):
-        # save the pre12_meta cache in any case
-        with open(os.path.join(self.path, 'pre12-meta'), 'w') as fd:
-            json.dump(self.pre12_meta, fd, indent=4)
         if self.cache_config is not None:
             self.cache_config.close()
             self.cache_config = None
@@ -1037,7 +1026,6 @@ Chunk index:    {0.total_unique_chunks:20d}             unknown"""
         self.security_manager = SecurityManager(repository)
         self.security_manager.assert_secure(manifest, key, lock_wait=lock_wait)
 
-        self.pre12_meta = {}
         logger.warning('Note: --no-cache-sync is an experimental feature.')
 
     # Public API

From 822aefc7b0b4c6a7a9ed30a24e60213a34ec9263 Mon Sep 17 00:00:00 2001
From: Thomas Waldmann <tw@waldmann-edv.de>
Date: Sun, 12 Jun 2022 00:17:20 +0200
Subject: [PATCH 038/160] re-add dsize placeholder

---
 src/borg/helpers/parseformat.py | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/src/borg/helpers/parseformat.py b/src/borg/helpers/parseformat.py
index 9b57baebb..43e8d05eb 100644
--- a/src/borg/helpers/parseformat.py
+++ b/src/borg/helpers/parseformat.py
@@ -698,6 +698,7 @@ class ItemFormatter(BaseFormatter):
         'source': 'link target for symlinks (identical to linktarget)',
         'hlid': 'hard link identity (same if hardlinking same fs object)',
         'extra': 'prepends {source} with " -> " for soft links and " link to " for hard links',
+        'dsize': 'deduplicated size',
         'num_chunks': 'number of chunks in this file',
         'unique_chunks': 'number of unique chunks in this file',
         'xxh64': 'XXH64 checksum of this file (note: this is NOT a cryptographic hash!)',
@@ -705,7 +706,7 @@ class ItemFormatter(BaseFormatter):
     }
     KEY_GROUPS = (
         ('type', 'mode', 'uid', 'gid', 'user', 'group', 'path', 'bpath', 'source', 'linktarget', 'hlid', 'flags'),
-        ('size', 'num_chunks', 'unique_chunks'),
+        ('size', 'dsize', 'num_chunks', 'unique_chunks'),
         ('mtime', 'ctime', 'atime', 'isomtime', 'isoctime', 'isoatime'),
         tuple(sorted(hash_algorithms)),
         ('archiveid', 'archivename', 'extra'),
@@ -713,7 +714,7 @@ class ItemFormatter(BaseFormatter):
     )
 
     KEYS_REQUIRING_CACHE = (
-        'unique_chunks',
+        'dsize', 'unique_chunks',
     )
 
     @classmethod
@@ -771,6 +772,7 @@ class ItemFormatter(BaseFormatter):
         self.format_keys = {f[1] for f in Formatter().parse(format)}
         self.call_keys = {
             'size': self.calculate_size,
+            'dsize': partial(self.sum_unique_chunks_metadata, lambda chunk: chunk.size),
             'num_chunks': self.calculate_num_chunks,
             'unique_chunks': partial(self.sum_unique_chunks_metadata, lambda chunk: 1),
             'isomtime': partial(self.format_iso_time, 'mtime'),

From 75ad3b8e35669fa4e703c85ff55a08776245163c Mon Sep 17 00:00:00 2001
From: Thomas Waldmann <tw@waldmann-edv.de>
Date: Sun, 12 Jun 2022 17:50:12 +0200
Subject: [PATCH 039/160] remove csize expectation from do_transfer
 upgrade_item

the size is already remove via Item._update_internal method.
---
 src/borg/archiver.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/borg/archiver.py b/src/borg/archiver.py
index 3814d1262..1a46e4350 100644
--- a/src/borg/archiver.py
+++ b/src/borg/archiver.py
@@ -361,7 +361,7 @@ class Archiver:
                 chunks, chunks_healthy = hlm.retrieve(id=hlid, default=(None, None))
                 if chunks is not None:
                     item._dict['chunks'] = chunks
-                    for chunk_id, _, _ in chunks:
+                    for chunk_id, _ in chunks:
                         cache.chunk_incref(chunk_id, archive.stats)
                 if chunks_healthy is not None:
                     item._dict['chunks_healthy'] = chunks

From 1393e4f391cc33cc776921996d0180431d74cdca Mon Sep 17 00:00:00 2001
From: Thomas Waldmann <tw@waldmann-edv.de>
Date: Sun, 12 Jun 2022 18:01:57 +0200
Subject: [PATCH 040/160] remove csize references from docs

---
 docs/internals/frontends.rst | 18 +++++-------------
 1 file changed, 5 insertions(+), 13 deletions(-)

diff --git a/docs/internals/frontends.rst b/docs/internals/frontends.rst
index 8ff5ff475..d0ebed48c 100644
--- a/docs/internals/frontends.rst
+++ b/docs/internals/frontends.rst
@@ -269,12 +269,8 @@ stats
         Number of unique chunks
     total_size
         Total uncompressed size of all chunks multiplied with their reference counts
-    total_csize
-        Total compressed and encrypted size of all chunks multiplied with their reference counts
     unique_size
         Uncompressed size of all chunks
-    unique_csize
-        Compressed and encrypted size of all chunks
 
 .. highlight: json
 
@@ -285,10 +281,8 @@ Example *borg info* output::
             "path": "/home/user/.cache/borg/0cbe6166b46627fd26b97f8831e2ca97584280a46714ef84d2b668daf8271a23",
             "stats": {
                 "total_chunks": 511533,
-                "total_csize": 17948017540,
                 "total_size": 22635749792,
                 "total_unique_chunks": 54892,
-                "unique_csize": 1920405405,
                 "unique_size": 2449675468
             }
         },
@@ -424,10 +418,8 @@ The same archive with more information (``borg info --last 1 --json``)::
             "path": "/home/user/.cache/borg/0cbe6166b46627fd26b97f8831e2ca97584280a46714ef84d2b668daf8271a23",
             "stats": {
                 "total_chunks": 511533,
-                "total_csize": 17948017540,
                 "total_size": 22635749792,
                 "total_unique_chunks": 54892,
-                "unique_csize": 1920405405,
                 "unique_size": 2449675468
             }
         },
@@ -495,26 +487,26 @@ added:
 
 removed:
     See **added** property.
-    
+
 old_mode:
     If **type** == '*mode*', then **old_mode** and **new_mode** provide the mode and permissions changes.
 
 new_mode:
     See **old_mode** property.
- 
+
 old_user:
     If **type** == '*owner*', then **old_user**, **new_user**, **old_group** and **new_group** provide the user
     and group ownership changes.
 
 old_group:
     See **old_user** property.
- 
+
 new_user:
     See **old_user** property.
- 
+
 new_group:
     See **old_user** property.
-    
+
 
 Example (excerpt) of ``borg diff --json-lines``::
 

From 3ce3fbcdff94b640a3cf64c0d95ee0866f9f056e Mon Sep 17 00:00:00 2001
From: Thomas Waldmann <tw@waldmann-edv.de>
Date: Thu, 12 May 2022 01:45:50 +0200
Subject: [PATCH 041/160] repository index: add payload size (==csize) and
 flags to NSIndex entries

This saves some segment file random IO that was previously necessary
just to determine the size of to be deleted data.

Keep old one as NSIndex1 for old borg compatibility.
Choose NSIndex or NSIndex1 based on repo index layout from HashHeader.

for an old repo index repo.get(key) returns segment, offset, None, None
---
 src/borg/hashindex.pyx           |  99 +++++++++++++++++++++++++++++-
 src/borg/repository.py           | 101 ++++++++++++++++++-------------
 src/borg/testsuite/hashindex.py  |  48 +++++++--------
 src/borg/testsuite/repository.py |   2 +-
 4 files changed, 181 insertions(+), 69 deletions(-)

diff --git a/src/borg/hashindex.pyx b/src/borg/hashindex.pyx
index 4b9fe316c..ace6c84fa 100644
--- a/src/borg/hashindex.pyx
+++ b/src/borg/hashindex.pyx
@@ -77,6 +77,20 @@ assert UINT32_MAX == 2**32-1
 assert _MAX_VALUE % 2 == 1
 
 
+def hashindex_variant(fn):
+    """peek into an index file and find out what it is"""
+    with open(fn, 'rb') as f:
+        hh = f.read(18)  # len(HashHeader)
+    magic = hh[0:8]
+    if magic == b'BORG_IDX':
+        key_size = hh[16]
+        value_size = hh[17]
+        return f'k{key_size}_v{value_size}'
+    if magic == b'12345678':  # used by unit tests
+        return 'k32_v16'  # just return the current variant
+    raise ValueError(f'unknown hashindex format, magic: {magic!r}')
+
+
 @cython.internal
 cdef class IndexBase:
     cdef HashIndex *index
@@ -196,8 +210,87 @@ cdef class FuseVersionsIndex(IndexBase):
         return hashindex_get(self.index, <unsigned char *>key) != NULL
 
 
+NSIndexEntry = namedtuple('NSIndexEntry', 'segment offset size extra')
+
+
 cdef class NSIndex(IndexBase):
 
+    value_size = 16
+
+    def __getitem__(self, key):
+        assert len(key) == self.key_size
+        data = <uint32_t *>hashindex_get(self.index, <unsigned char *>key)
+        if not data:
+            raise KeyError(key)
+        cdef uint32_t segment = _le32toh(data[0])
+        assert segment <= _MAX_VALUE, "maximum number of segments reached"
+        return NSIndexEntry(segment, _le32toh(data[1]), _le32toh(data[2]), _le32toh(data[3]))
+
+    def __setitem__(self, key, value):
+        assert len(key) == self.key_size
+        cdef uint32_t[4] data
+        cdef uint32_t segment = value[0]
+        assert segment <= _MAX_VALUE, "maximum number of segments reached"
+        data[0] = _htole32(segment)
+        data[1] = _htole32(value[1])
+        data[2] = _htole32(value[2])
+        data[3] = _htole32(value[3])
+        if not hashindex_set(self.index, <unsigned char *>key, data):
+            raise Exception('hashindex_set failed')
+
+    def __contains__(self, key):
+        cdef uint32_t segment
+        assert len(key) == self.key_size
+        data = <uint32_t *>hashindex_get(self.index, <unsigned char *>key)
+        if data != NULL:
+            segment = _le32toh(data[0])
+            assert segment <= _MAX_VALUE, "maximum number of segments reached"
+        return data != NULL
+
+    def iteritems(self, marker=None):
+        cdef const unsigned char *key
+        iter = NSKeyIterator(self.key_size)
+        iter.idx = self
+        iter.index = self.index
+        if marker:
+            key = hashindex_get(self.index, <unsigned char *>marker)
+            if marker is None:
+                raise IndexError
+            iter.key = key - self.key_size
+        return iter
+
+
+cdef class NSKeyIterator:
+    cdef NSIndex idx
+    cdef HashIndex *index
+    cdef const unsigned char *key
+    cdef int key_size
+    cdef int exhausted
+
+    def __cinit__(self, key_size):
+        self.key = NULL
+        self.key_size = key_size
+        self.exhausted = 0
+
+    def __iter__(self):
+        return self
+
+    def __next__(self):
+        if self.exhausted:
+            raise StopIteration
+        self.key = hashindex_next_key(self.index, <unsigned char *>self.key)
+        if not self.key:
+            self.exhausted = 1
+            raise StopIteration
+        cdef uint32_t *value = <uint32_t *>(self.key + self.key_size)
+        cdef uint32_t segment = _le32toh(value[0])
+        assert segment <= _MAX_VALUE, "maximum number of segments reached"
+        return ((<char *>self.key)[:self.key_size],
+                NSIndexEntry(segment, _le32toh(value[1]), _le32toh(value[2]), _le32toh(value[3])))
+
+
+cdef class NSIndex1(IndexBase):  # legacy borg 1.x
+
     value_size = 8
 
     def __getitem__(self, key):
@@ -230,7 +323,7 @@ cdef class NSIndex(IndexBase):
 
     def iteritems(self, marker=None):
         cdef const unsigned char *key
-        iter = NSKeyIterator(self.key_size)
+        iter = NSKeyIterator1(self.key_size)
         iter.idx = self
         iter.index = self.index
         if marker:
@@ -241,8 +334,8 @@ cdef class NSIndex(IndexBase):
         return iter
 
 
-cdef class NSKeyIterator:
-    cdef NSIndex idx
+cdef class NSKeyIterator1:  # legacy borg 1.x
+    cdef NSIndex1 idx
     cdef HashIndex *index
     cdef const unsigned char *key
     cdef int key_size
diff --git a/src/borg/repository.py b/src/borg/repository.py
index 3fcc72aad..3e6ec2d29 100644
--- a/src/borg/repository.py
+++ b/src/borg/repository.py
@@ -13,7 +13,7 @@ from functools import partial
 from itertools import islice
 
 from .constants import *  # NOQA
-from .hashindex import NSIndex
+from .hashindex import NSIndexEntry, NSIndex, NSIndex1, hashindex_variant
 from .helpers import Error, ErrorWithTraceback, IntegrityError, format_file_size, parse_file_size
 from .helpers import Location
 from .helpers import ProgressIndicatorPercent
@@ -52,6 +52,18 @@ MAX_TAG_ID = 15
 FreeSpace = partial(defaultdict, int)
 
 
+def header_size(tag):
+    if tag == TAG_PUT2:
+        size = LoggedIO.HEADER_ID_SIZE + LoggedIO.ENTRY_HASH_SIZE
+    elif tag == TAG_PUT or tag == TAG_DELETE:
+        size = LoggedIO.HEADER_ID_SIZE
+    elif tag == TAG_COMMIT:
+        size = LoggedIO.header_fmt.size
+    else:
+        raise ValueError(f"unsupported tag: {tag!r}")
+    return size
+
+
 class Repository:
     """
     Filesystem based transactional key value store
@@ -525,10 +537,14 @@ class Repository:
         if transaction_id is None:
             return NSIndex()
         index_path = os.path.join(self.path, 'index.%d' % transaction_id)
+        variant = hashindex_variant(index_path)
         integrity_data = self._read_integrity(transaction_id, 'index')
         try:
             with IntegrityCheckedFile(index_path, write=False, integrity_data=integrity_data) as fd:
-                return NSIndex.read(fd)
+                if variant == 'k32_v16':
+                    return NSIndex.read(fd)
+                if variant == 'k32_v8':  # legacy
+                    return NSIndex1.read(fd)
         except (ValueError, OSError, FileIntegrityError) as exc:
             logger.warning('Repository index missing or corrupted, trying to recover from: %s', exc)
             os.unlink(index_path)
@@ -798,14 +814,14 @@ class Repository:
                 if tag == TAG_COMMIT:
                     continue
                 in_index = self.index.get(key)
-                is_index_object = in_index == (segment, offset)
+                is_index_object = in_index and (in_index.segment, in_index.offset) == (segment, offset)
                 if tag in (TAG_PUT2, TAG_PUT) and is_index_object:
                     try:
                         new_segment, offset = self.io.write_put(key, data, raise_full=True)
                     except LoggedIO.SegmentFull:
                         complete_xfer()
                         new_segment, offset = self.io.write_put(key, data)
-                    self.index[key] = new_segment, offset
+                    self.index[key] = NSIndexEntry(new_segment, offset, len(data), in_index.extra)
                     segments.setdefault(new_segment, 0)
                     segments[new_segment] += 1
                     segments[segment] -= 1
@@ -821,10 +837,7 @@ class Repository:
                         # do not remove entry with empty shadowed_segments list here,
                         # it is needed for shadowed_put_exists code (see below)!
                         pass
-                    if tag == TAG_PUT2:
-                        self.storage_quota_use -= len(data) + self.io.HEADER_ID_SIZE + self.io.ENTRY_HASH_SIZE
-                    elif tag == TAG_PUT:
-                        self.storage_quota_use -= len(data) + self.io.HEADER_ID_SIZE
+                    self.storage_quota_use -= header_size(tag) + len(data)
                 elif tag == TAG_DELETE and not in_index:
                     # If the shadow index doesn't contain this key, then we can't say if there's a shadowed older tag,
                     # therefore we do not drop the delete, but write it to a current segment.
@@ -919,27 +932,26 @@ class Repository:
             if tag in (TAG_PUT2, TAG_PUT):
                 try:
                     # If this PUT supersedes an older PUT, mark the old segment for compaction and count the free space
-                    s, _ = self.index[key]
-                    self.compact[s] += size
-                    self.segments[s] -= 1
+                    in_index = self.index[key]
+                    self.compact[in_index.segment] += header_size(tag) + size
+                    self.segments[in_index.segment] -= 1
                 except KeyError:
                     pass
-                self.index[key] = segment, offset
+                self.index[key] = NSIndexEntry(segment, offset, size, 0)
                 self.segments[segment] += 1
-                self.storage_quota_use += size  # note: size already includes the put_header_fmt overhead
+                self.storage_quota_use += header_size(tag) + size
             elif tag == TAG_DELETE:
                 try:
                     # if the deleted PUT is not in the index, there is nothing to clean up
-                    s, offset = self.index.pop(key)
+                    in_index = self.index.pop(key)
                 except KeyError:
                     pass
                 else:
-                    if self.io.segment_exists(s):
+                    if self.io.segment_exists(in_index.segment):
                         # the old index is not necessarily valid for this transaction (e.g. compaction); if the segment
                         # is already gone, then it was already compacted.
-                        self.segments[s] -= 1
-                        size = self.io.read(s, offset, key, read_data=False)
-                        self.compact[s] += size
+                        self.segments[in_index.segment] -= 1
+                        self.compact[in_index.segment] += header_size(tag) + in_index.size
             elif tag == TAG_COMMIT:
                 continue
             else:
@@ -968,12 +980,13 @@ class Repository:
         self.compact[segment] = 0
         for tag, key, offset, size in self.io.iter_objects(segment, read_data=False):
             if tag in (TAG_PUT2, TAG_PUT):
-                if self.index.get(key, (-1, -1)) != (segment, offset):
+                in_index = self.index.get(key)
+                if not in_index or (in_index.segment, in_index.offset) != (segment, offset):
                     # This PUT is superseded later
-                    self.compact[segment] += size
+                    self.compact[segment] += header_size(tag) + size
             elif tag == TAG_DELETE:
                 # The outcome of the DELETE has been recorded in the PUT branch already
-                self.compact[segment] += size
+                self.compact[segment] += header_size(tag) + size
 
     def check(self, repair=False, save_space=False, max_duration=0):
         """Check repository consistency
@@ -1169,7 +1182,7 @@ class Repository:
             self.index = self.open_index(transaction_id)
         at_start = marker is None
         # smallest valid seg is <uint32> 0, smallest valid offs is <uint32> 8
-        start_segment, start_offset = (0, 0) if at_start else self.index[marker]
+        start_segment, start_offset, _, _ = (0, 0, 0, 0) if at_start else self.index[marker]
         result = []
         for segment, filename in self.io.segment_iterator(start_segment):
             obj_iterator = self.io.iter_objects(segment, start_offset, read_data=False, include_data=False)
@@ -1186,19 +1199,21 @@ class Repository:
                     # also, for the next segment, we need to start at offset 0.
                     start_offset = 0
                     continue
-                if tag in (TAG_PUT2, TAG_PUT) and (segment, offset) == self.index.get(id):
-                    # we have found an existing and current object
-                    result.append(id)
-                    if len(result) == limit:
-                        return result
+                if tag in (TAG_PUT2, TAG_PUT):
+                    in_index = self.index.get(id)
+                    if in_index and (in_index.segment, in_index.offset) == (segment, offset):
+                        # we have found an existing and current object
+                        result.append(id)
+                        if len(result) == limit:
+                            return result
         return result
 
     def get(self, id):
         if not self.index:
             self.index = self.open_index(self.get_transaction_id())
         try:
-            segment, offset = self.index[id]
-            return self.io.read(segment, offset, id)
+            in_index = NSIndexEntry(*((self.index[id] + (None, None))[:4]))  # legacy: no size/extra
+            return self.io.read(in_index.segment, in_index.offset, id, expected_size=in_index.size)
         except KeyError:
             raise self.ObjectNotFound(id, self.path) from None
 
@@ -1215,7 +1230,7 @@ class Repository:
         if not self._active_txn:
             self.prepare_txn(self.get_transaction_id())
         try:
-            segment, offset = self.index[id]
+            in_index = self.index[id]
         except KeyError:
             pass
         else:
@@ -1223,12 +1238,12 @@ class Repository:
             # we do not want to update the shadow_index here, because
             # we know already that we will PUT to this id, so it will
             # be in the repo index (and we won't need it in the shadow_index).
-            self._delete(id, segment, offset, update_shadow_index=False)
+            self._delete(id, in_index.segment, in_index.offset, in_index.size, update_shadow_index=False)
         segment, offset = self.io.write_put(id, data)
-        self.storage_quota_use += len(data) + self.io.HEADER_ID_SIZE + self.io.ENTRY_HASH_SIZE
+        self.storage_quota_use += header_size(TAG_PUT2) + len(data)
         self.segments.setdefault(segment, 0)
         self.segments[segment] += 1
-        self.index[id] = segment, offset
+        self.index[id] = NSIndexEntry(segment, offset, len(data), 0)
         if self.storage_quota and self.storage_quota_use > self.storage_quota:
             self.transaction_doomed = self.StorageQuotaExceeded(
                 format_file_size(self.storage_quota), format_file_size(self.storage_quota_use))
@@ -1243,22 +1258,21 @@ class Repository:
         if not self._active_txn:
             self.prepare_txn(self.get_transaction_id())
         try:
-            segment, offset = self.index.pop(id)
+            in_index = self.index.pop(id)
         except KeyError:
             raise self.ObjectNotFound(id, self.path) from None
         # if we get here, there is an object with this id in the repo,
         # we write a DEL here that shadows the respective PUT.
         # after the delete, the object is not in the repo index any more,
         # for the compaction code, we need to update the shadow_index in this case.
-        self._delete(id, segment, offset, update_shadow_index=True)
+        self._delete(id, in_index.segment, in_index.offset, in_index.size, update_shadow_index=True)
 
-    def _delete(self, id, segment, offset, *, update_shadow_index):
+    def _delete(self, id, segment, offset, size, *, update_shadow_index):
         # common code used by put and delete
         if update_shadow_index:
             self.shadow_index.setdefault(id, []).append(segment)
         self.segments[segment] -= 1
-        size = self.io.read(segment, offset, id, read_data=False)
-        self.compact[segment] += size
+        self.compact[segment] += header_size(TAG_PUT2) + size
         segment, size = self.io.write_delete(id)
         self.compact[segment] += size
         self.segments.setdefault(segment, 0)
@@ -1515,7 +1529,8 @@ class LoggedIO:
             if include_data:
                 yield tag, key, offset, data
             else:
-                yield tag, key, offset, size
+                yield tag, key, offset, size - header_size(tag)  # corresponds to len(data)
+            assert size >= 0
             offset += size
             # we must get the fd via get_fd() here again as we yielded to our caller and it might
             # have triggered closing of the fd we had before (e.g. by calling io.read() for
@@ -1580,7 +1595,7 @@ class LoggedIO:
             h.update(d)
         return h.digest()
 
-    def read(self, segment, offset, id, read_data=True):
+    def read(self, segment, offset, id, read_data=True, *, expected_size=None):
         """
         Read entry from *segment* at *offset* with *id*.
         If read_data is False the size of the entry is returned instead.
@@ -1596,7 +1611,11 @@ class LoggedIO:
         if id != key:
             raise IntegrityError('Invalid segment entry header, is not for wanted id [segment {}, offset {}]'.format(
                 segment, offset))
-        return data if read_data else size
+        data_size_from_header = size - header_size(tag)
+        if expected_size is not None and expected_size != data_size_from_header:
+            raise IntegrityError(f'size from repository index: {expected_size} != '
+                                 f'size from entry header: {data_size_from_header}')
+        return data if read_data else data_size_from_header
 
     def _read(self, fd, header, segment, offset, acceptable_tags, read_data=True):
         """
diff --git a/src/borg/testsuite/hashindex.py b/src/borg/testsuite/hashindex.py
index 7a3b53e33..537151e07 100644
--- a/src/borg/testsuite/hashindex.py
+++ b/src/borg/testsuite/hashindex.py
@@ -87,8 +87,8 @@ class HashIndexTestCase(BaseTestCase):
         del idx
 
     def test_nsindex(self):
-        self._generic_test(NSIndex, lambda x: (x, x),
-                           '85f72b036c692c8266e4f51ccf0cff2147204282b5e316ae508d30a448d88fef')
+        self._generic_test(NSIndex, lambda x: (x, x, x, x),
+                           'c9fe5878800d2a0691b667c665a00d4a186e204e891076d6b109016940742bed')
 
     def test_chunkindex(self):
         self._generic_test(ChunkIndex, lambda x: (x, x),
@@ -102,7 +102,7 @@ class HashIndexTestCase(BaseTestCase):
             initial_size = os.path.getsize(filepath)
             self.assert_equal(len(idx), 0)
             for x in range(n):
-                idx[H(x)] = x, x
+                idx[H(x)] = x, x, x, x
             idx.write(filepath)
             assert initial_size < os.path.getsize(filepath)
             for x in range(n):
@@ -114,7 +114,7 @@ class HashIndexTestCase(BaseTestCase):
     def test_iteritems(self):
         idx = NSIndex()
         for x in range(100):
-            idx[H(x)] = x, x
+            idx[H(x)] = x, x, x, x
         iterator = idx.iteritems()
         all = list(iterator)
         self.assert_equal(len(all), 100)
@@ -514,9 +514,9 @@ class NSIndexTestCase(BaseTestCase):
     def test_nsindex_segment_limit(self):
         idx = NSIndex()
         with self.assert_raises(AssertionError):
-            idx[H(1)] = NSIndex.MAX_VALUE + 1, 0
+            idx[H(1)] = NSIndex.MAX_VALUE + 1, 0, 0, 0
         assert H(1) not in idx
-        idx[H(2)] = NSIndex.MAX_VALUE, 0
+        idx[H(2)] = NSIndex.MAX_VALUE, 0, 0, 0
         assert H(2) in idx
 
 
@@ -531,38 +531,38 @@ class IndexCorruptionTestCase(BaseTestCase):
 
         from struct import pack
 
-        def HH(x, y):
-            # make some 32byte long thing that depends on x and y.
-            # same x will mean a collision in the hashtable as bucket index is computed from
-            # first 4 bytes. giving a specific x targets bucket index x.
-            # y is to create different keys and does not go into the bucket index calculation.
-            # so, same x + different y --> collision
-            return pack('<IIQQQ', x, y, 0, 0, 0)  # 2 * 4 + 3 * 8 == 32
+        def HH(w, x, y, z):
+            # make some 32byte long thing that depends on w, x, y, z.
+            # same w will mean a collision in the hashtable as bucket index is computed from
+            # first 4 bytes. giving a specific w targets bucket index w.
+            # x is to create different keys and does not go into the bucket index calculation.
+            # so, same w + different x --> collision
+            return pack('<IIIIIIII', w, x, y, z, 0, 0, 0, 0)  # 8 * 4 == 32
 
         idx = NSIndex()
 
         # create lots of colliding entries
-        for y in range(700):  # stay below max load to not trigger resize
-            idx[HH(0, y)] = (0, y)
+        for x in range(700):  # stay below max load to not trigger resize
+            idx[HH(0, x, 0, 0)] = (0, x, 0, 0)
 
-        assert idx.size() == 1031 * 40 + 18  # 1031 buckets + header
+        assert idx.size() == 1031 * 48 + 18  # 1031 buckets + header
 
         # delete lots of the collisions, creating lots of tombstones
-        for y in range(400):  # stay above min load to not trigger resize
-            del idx[HH(0, y)]
+        for x in range(400):  # stay above min load to not trigger resize
+            del idx[HH(0, x, 0, 0)]
 
         # create lots of colliding entries, within the not yet used part of the hashtable
-        for y in range(330):  # stay below max load to not trigger resize
-            # at y == 259 a resize will happen due to going beyond max EFFECTIVE load
+        for x in range(330):  # stay below max load to not trigger resize
+            # at x == 259 a resize will happen due to going beyond max EFFECTIVE load
             # if the bug is present, that element will be inserted at the wrong place.
             # and because it will be at the wrong place, it can not be found again.
-            idx[HH(600, y)] = 600, y
+            idx[HH(600, x, 0, 0)] = 600, x, 0, 0
 
         # now check if hashtable contents is as expected:
 
-        assert [idx.get(HH(0, y)) for y in range(400, 700)] == [(0, y) for y in range(400, 700)]
+        assert [idx.get(HH(0, x, 0, 0)) for x in range(400, 700)] == [(0, x, 0, 0) for x in range(400, 700)]
 
-        assert [HH(0, y) in idx for y in range(400)] == [False for y in range(400)]  # deleted entries
+        assert [HH(0, x, 0, 0) in idx for x in range(400)] == [False for x in range(400)]  # deleted entries
 
         # this will fail at HH(600, 259) if the bug is present.
-        assert [idx.get(HH(600, y)) for y in range(330)] == [(600, y) for y in range(330)]
+        assert [idx.get(HH(600, x, 0, 0)) for x in range(330)] == [(600, x, 0, 0) for x in range(330)]
diff --git a/src/borg/testsuite/repository.py b/src/borg/testsuite/repository.py
index 52f03e668..180848c8e 100644
--- a/src/borg/testsuite/repository.py
+++ b/src/borg/testsuite/repository.py
@@ -714,7 +714,7 @@ class RepositoryCheckTestCase(RepositoryTestCaseBase):
 
     def corrupt_object(self, id_):
         idx = self.open_index()
-        segment, offset = idx[H(id_)]
+        segment, offset, _, _ = idx[H(id_)]
         with open(os.path.join(self.tmppath, 'repository', 'data', '0', str(segment)), 'r+b') as fd:
             fd.seek(offset)
             fd.write(b'BOOM')

From bf9f42320e72d0e288c9c3754836aabe7598baa5 Mon Sep 17 00:00:00 2001
From: Thomas Waldmann <tw@waldmann-edv.de>
Date: Thu, 12 May 2022 14:07:44 +0200
Subject: [PATCH 042/160] repository: sync write file in get_fd

this fixes a strange test failure that did not happen until now:
it could not read the MAGIC bytes from a (quite new) segment file,
it just returned the empty string.

maybe its appearance is related to the removed I/O calls.
---
 src/borg/repository.py | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/src/borg/repository.py b/src/borg/repository.py
index 3e6ec2d29..1de071dae 100644
--- a/src/borg/repository.py
+++ b/src/borg/repository.py
@@ -1462,6 +1462,9 @@ class LoggedIO:
                         del self.fds[k]
 
         clean_old()
+        if self._write_fd is not None:
+            # without this, we have a test failure now
+            self._write_fd.sync()
         try:
             ts, fd = self.fds[segment]
         except KeyError:

From e5ea01611560a2113842769ce3e1d08a2e86b2bb Mon Sep 17 00:00:00 2001
From: Thomas Waldmann <tw@waldmann-edv.de>
Date: Thu, 9 Jun 2022 20:15:25 +0200
Subject: [PATCH 043/160] repository: set/query flags, iteration over flagged
 items (NSIndex)

use this to query or set/clear flags in the "extra" word.

also: remove direct access to the "extra" word, adapt tests.
---
 src/borg/hashindex.pyx           |  52 ++++++++++++----
 src/borg/repository.py           |  10 +--
 src/borg/selftest.py             |   2 +-
 src/borg/testsuite/hashindex.py  | 102 +++++++++++++++++++++++++------
 src/borg/testsuite/repository.py |   2 +-
 5 files changed, 130 insertions(+), 38 deletions(-)

diff --git a/src/borg/hashindex.pyx b/src/borg/hashindex.pyx
index ace6c84fa..3cb8d5a4d 100644
--- a/src/borg/hashindex.pyx
+++ b/src/borg/hashindex.pyx
@@ -210,7 +210,7 @@ cdef class FuseVersionsIndex(IndexBase):
         return hashindex_get(self.index, <unsigned char *>key) != NULL
 
 
-NSIndexEntry = namedtuple('NSIndexEntry', 'segment offset size extra')
+NSIndexEntry = namedtuple('NSIndexEntry', 'segment offset size')
 
 
 cdef class NSIndex(IndexBase):
@@ -224,7 +224,7 @@ cdef class NSIndex(IndexBase):
             raise KeyError(key)
         cdef uint32_t segment = _le32toh(data[0])
         assert segment <= _MAX_VALUE, "maximum number of segments reached"
-        return NSIndexEntry(segment, _le32toh(data[1]), _le32toh(data[2]), _le32toh(data[3]))
+        return NSIndexEntry(segment, _le32toh(data[1]), _le32toh(data[2]))
 
     def __setitem__(self, key, value):
         assert len(key) == self.key_size
@@ -234,7 +234,7 @@ cdef class NSIndex(IndexBase):
         data[0] = _htole32(segment)
         data[1] = _htole32(value[1])
         data[2] = _htole32(value[2])
-        data[3] = _htole32(value[3])
+        data[3] = 0  # init flags to all cleared
         if not hashindex_set(self.index, <unsigned char *>key, data):
             raise Exception('hashindex_set failed')
 
@@ -247,9 +247,12 @@ cdef class NSIndex(IndexBase):
             assert segment <= _MAX_VALUE, "maximum number of segments reached"
         return data != NULL
 
-    def iteritems(self, marker=None):
+    def iteritems(self, marker=None, mask=0, value=0):
+        """iterate over all items or optionally only over items having specific flag values"""
         cdef const unsigned char *key
-        iter = NSKeyIterator(self.key_size)
+        assert isinstance(mask, int)
+        assert isinstance(value, int)
+        iter = NSKeyIterator(self.key_size, mask, value)
         iter.idx = self
         iter.index = self.index
         if marker:
@@ -259,6 +262,20 @@ cdef class NSIndex(IndexBase):
             iter.key = key - self.key_size
         return iter
 
+    def flags(self, key, mask=0xFFFFFFFF, value=None):
+        """query and optionally set flags"""
+        assert len(key) == self.key_size
+        assert isinstance(mask, int)
+        data = <uint32_t *>hashindex_get(self.index, <unsigned char *>key)
+        if not data:
+            raise KeyError(key)
+        flags = _le32toh(data[3])
+        if isinstance(value, int):
+            new_flags = flags & ~mask  # clear masked bits
+            new_flags |= value & mask  # set value bits
+            data[3] = _htole32(new_flags)
+        return flags & mask # always return previous flags value
+
 
 cdef class NSKeyIterator:
     cdef NSIndex idx
@@ -266,27 +283,38 @@ cdef class NSKeyIterator:
     cdef const unsigned char *key
     cdef int key_size
     cdef int exhausted
+    cdef int flag_mask
+    cdef int flag_value
 
-    def __cinit__(self, key_size):
+    def __cinit__(self, key_size, mask, value):
         self.key = NULL
         self.key_size = key_size
+        # note: mask and value both default to 0, so they will match all entries
+        self.flag_mask = _htole32(mask)
+        self.flag_value = _htole32(value)
         self.exhausted = 0
 
     def __iter__(self):
         return self
 
     def __next__(self):
+        cdef uint32_t *value
         if self.exhausted:
             raise StopIteration
-        self.key = hashindex_next_key(self.index, <unsigned char *>self.key)
-        if not self.key:
-            self.exhausted = 1
-            raise StopIteration
-        cdef uint32_t *value = <uint32_t *>(self.key + self.key_size)
+        while True:
+            self.key = hashindex_next_key(self.index, <unsigned char *>self.key)
+            if not self.key:
+                self.exhausted = 1
+                raise StopIteration
+            value = <uint32_t *> (self.key + self.key_size)
+            if value[3] & self.flag_mask == self.flag_value:
+                # we found a matching entry!
+                break
+
         cdef uint32_t segment = _le32toh(value[0])
         assert segment <= _MAX_VALUE, "maximum number of segments reached"
         return ((<char *>self.key)[:self.key_size],
-                NSIndexEntry(segment, _le32toh(value[1]), _le32toh(value[2]), _le32toh(value[3])))
+                NSIndexEntry(segment, _le32toh(value[1]), _le32toh(value[2])))
 
 
 cdef class NSIndex1(IndexBase):  # legacy borg 1.x
diff --git a/src/borg/repository.py b/src/borg/repository.py
index 1de071dae..1020a1eab 100644
--- a/src/borg/repository.py
+++ b/src/borg/repository.py
@@ -821,7 +821,7 @@ class Repository:
                     except LoggedIO.SegmentFull:
                         complete_xfer()
                         new_segment, offset = self.io.write_put(key, data)
-                    self.index[key] = NSIndexEntry(new_segment, offset, len(data), in_index.extra)
+                    self.index[key] = NSIndexEntry(new_segment, offset, len(data))
                     segments.setdefault(new_segment, 0)
                     segments[new_segment] += 1
                     segments[segment] -= 1
@@ -937,7 +937,7 @@ class Repository:
                     self.segments[in_index.segment] -= 1
                 except KeyError:
                     pass
-                self.index[key] = NSIndexEntry(segment, offset, size, 0)
+                self.index[key] = NSIndexEntry(segment, offset, size)
                 self.segments[segment] += 1
                 self.storage_quota_use += header_size(tag) + size
             elif tag == TAG_DELETE:
@@ -1182,7 +1182,7 @@ class Repository:
             self.index = self.open_index(transaction_id)
         at_start = marker is None
         # smallest valid seg is <uint32> 0, smallest valid offs is <uint32> 8
-        start_segment, start_offset, _, _ = (0, 0, 0, 0) if at_start else self.index[marker]
+        start_segment, start_offset, _ = (0, 0, 0) if at_start else self.index[marker]
         result = []
         for segment, filename in self.io.segment_iterator(start_segment):
             obj_iterator = self.io.iter_objects(segment, start_offset, read_data=False, include_data=False)
@@ -1212,7 +1212,7 @@ class Repository:
         if not self.index:
             self.index = self.open_index(self.get_transaction_id())
         try:
-            in_index = NSIndexEntry(*((self.index[id] + (None, None))[:4]))  # legacy: no size/extra
+            in_index = NSIndexEntry(*((self.index[id] + (None, ))[:3]))  # legacy: index entriess have no size element
             return self.io.read(in_index.segment, in_index.offset, id, expected_size=in_index.size)
         except KeyError:
             raise self.ObjectNotFound(id, self.path) from None
@@ -1243,7 +1243,7 @@ class Repository:
         self.storage_quota_use += header_size(TAG_PUT2) + len(data)
         self.segments.setdefault(segment, 0)
         self.segments[segment] += 1
-        self.index[id] = NSIndexEntry(segment, offset, len(data), 0)
+        self.index[id] = NSIndexEntry(segment, offset, len(data))
         if self.storage_quota and self.storage_quota_use > self.storage_quota:
             self.transaction_doomed = self.StorageQuotaExceeded(
                 format_file_size(self.storage_quota), format_file_size(self.storage_quota_use))
diff --git a/src/borg/selftest.py b/src/borg/selftest.py
index 006e85a56..00356cd0e 100644
--- a/src/borg/selftest.py
+++ b/src/borg/selftest.py
@@ -33,7 +33,7 @@ SELFTEST_CASES = [
     ChunkerTestCase,
 ]
 
-SELFTEST_COUNT = 36
+SELFTEST_COUNT = 37
 
 
 class SelfTestResult(TestResult):
diff --git a/src/borg/testsuite/hashindex.py b/src/borg/testsuite/hashindex.py
index 537151e07..b05ff77fd 100644
--- a/src/borg/testsuite/hashindex.py
+++ b/src/borg/testsuite/hashindex.py
@@ -87,8 +87,8 @@ class HashIndexTestCase(BaseTestCase):
         del idx
 
     def test_nsindex(self):
-        self._generic_test(NSIndex, lambda x: (x, x, x, x),
-                           'c9fe5878800d2a0691b667c665a00d4a186e204e891076d6b109016940742bed')
+        self._generic_test(NSIndex, lambda x: (x, x, x),
+                           '7d70671d0b7e9d2f51b2691ecf35184b9f8ecc1202cceb2748c905c8fc04c256')
 
     def test_chunkindex(self):
         self._generic_test(ChunkIndex, lambda x: (x, x),
@@ -153,6 +153,70 @@ class HashIndexTestCase(BaseTestCase):
         assert chunks == 1 + 2 + 3
         assert unique_chunks == 3
 
+    def test_flags(self):
+        idx = NSIndex()
+        key = H(0)
+        self.assert_raises(KeyError, idx.flags, key, 0)
+        idx[key] = 0, 0, 0  # create entry
+        # check bit 0 and 1, should be both 0 after entry creation
+        self.assert_equal(idx.flags(key, mask=3), 0)
+        # set bit 0
+        idx.flags(key, mask=1, value=1)
+        self.assert_equal(idx.flags(key, mask=1), 1)
+        # set bit 1
+        idx.flags(key, mask=2, value=2)
+        self.assert_equal(idx.flags(key, mask=2), 2)
+        # check both bit 0 and 1, both should be set
+        self.assert_equal(idx.flags(key, mask=3), 3)
+        # clear bit 1
+        idx.flags(key, mask=2, value=0)
+        self.assert_equal(idx.flags(key, mask=2), 0)
+        # clear bit 0
+        idx.flags(key, mask=1, value=0)
+        self.assert_equal(idx.flags(key, mask=1), 0)
+        # check both bit 0 and 1, both should be cleared
+        self.assert_equal(idx.flags(key, mask=3), 0)
+
+    def test_flags_iteritems(self):
+        idx = NSIndex()
+        keys_flagged0 = {H(i) for i in (1, 2, 3, 42)}
+        keys_flagged1 = {H(i) for i in (11, 12, 13, 142)}
+        keys_flagged2 = {H(i) for i in (21, 22, 23, 242)}
+        keys_flagged3 = {H(i) for i in (31, 32, 33, 342)}
+        for key in keys_flagged0:
+            idx[key] = 0, 0, 0  # create entry
+            idx.flags(key, mask=3, value=0)  # not really necessary, unflagged is default
+        for key in keys_flagged1:
+            idx[key] = 0, 0, 0  # create entry
+            idx.flags(key, mask=3, value=1)
+        for key in keys_flagged2:
+            idx[key] = 0, 0, 0  # create entry
+            idx.flags(key, mask=3, value=2)
+        for key in keys_flagged3:
+            idx[key] = 0, 0, 0  # create entry
+            idx.flags(key, mask=3, value=3)
+        # check if we can iterate over all items
+        k_all = {k for k, v in idx.iteritems()}
+        self.assert_equal(k_all, keys_flagged0 | keys_flagged1 | keys_flagged2 | keys_flagged3)
+        # check if we can iterate over the flagged0 items
+        k0 = {k for k, v in idx.iteritems(mask=3, value=0)}
+        self.assert_equal(k0, keys_flagged0)
+        # check if we can iterate over the flagged1 items
+        k1 = {k for k, v in idx.iteritems(mask=3, value=1)}
+        self.assert_equal(k1, keys_flagged1)
+        # check if we can iterate over the flagged2 items
+        k1 = {k for k, v in idx.iteritems(mask=3, value=2)}
+        self.assert_equal(k1, keys_flagged2)
+        # check if we can iterate over the flagged3 items
+        k1 = {k for k, v in idx.iteritems(mask=3, value=3)}
+        self.assert_equal(k1, keys_flagged3)
+        # check if we can iterate over the flagged1 + flagged3 items
+        k1 = {k for k, v in idx.iteritems(mask=1, value=1)}
+        self.assert_equal(k1, keys_flagged1 | keys_flagged3)
+        # check if we can iterate over the flagged0 + flagged2 items
+        k1 = {k for k, v in idx.iteritems(mask=1, value=0)}
+        self.assert_equal(k1, keys_flagged0 | keys_flagged2)
+
 
 class HashIndexExtraTestCase(BaseTestCase):
     """These tests are separate because they should not become part of the selftest.
@@ -531,38 +595,38 @@ class IndexCorruptionTestCase(BaseTestCase):
 
         from struct import pack
 
-        def HH(w, x, y, z):
-            # make some 32byte long thing that depends on w, x, y, z.
-            # same w will mean a collision in the hashtable as bucket index is computed from
-            # first 4 bytes. giving a specific w targets bucket index w.
-            # x is to create different keys and does not go into the bucket index calculation.
-            # so, same w + different x --> collision
-            return pack('<IIIIIIII', w, x, y, z, 0, 0, 0, 0)  # 8 * 4 == 32
+        def HH(x, y, z):
+            # make some 32byte long thing that depends on x, y, z.
+            # same x will mean a collision in the hashtable as bucket index is computed from
+            # first 4 bytes. giving a specific x targets bucket index x.
+            # y is to create different keys and does not go into the bucket index calculation.
+            # so, same x + different y --> collision
+            return pack('<IIIIIIII', x, y, z, 0, 0, 0, 0, 0)  # 8 * 4 == 32
 
         idx = NSIndex()
 
         # create lots of colliding entries
-        for x in range(700):  # stay below max load to not trigger resize
-            idx[HH(0, x, 0, 0)] = (0, x, 0, 0)
+        for y in range(700):  # stay below max load to not trigger resize
+            idx[HH(0, y, 0)] = (0, y, 0)
 
         assert idx.size() == 1031 * 48 + 18  # 1031 buckets + header
 
         # delete lots of the collisions, creating lots of tombstones
-        for x in range(400):  # stay above min load to not trigger resize
-            del idx[HH(0, x, 0, 0)]
+        for y in range(400):  # stay above min load to not trigger resize
+            del idx[HH(0, y, 0)]
 
         # create lots of colliding entries, within the not yet used part of the hashtable
-        for x in range(330):  # stay below max load to not trigger resize
-            # at x == 259 a resize will happen due to going beyond max EFFECTIVE load
+        for y in range(330):  # stay below max load to not trigger resize
+            # at y == 259 a resize will happen due to going beyond max EFFECTIVE load
             # if the bug is present, that element will be inserted at the wrong place.
             # and because it will be at the wrong place, it can not be found again.
-            idx[HH(600, x, 0, 0)] = 600, x, 0, 0
+            idx[HH(600, y, 0)] = 600, y, 0
 
         # now check if hashtable contents is as expected:
 
-        assert [idx.get(HH(0, x, 0, 0)) for x in range(400, 700)] == [(0, x, 0, 0) for x in range(400, 700)]
+        assert [idx.get(HH(0, y, 0)) for y in range(400, 700)] == [(0, y, 0) for y in range(400, 700)]
 
-        assert [HH(0, x, 0, 0) in idx for x in range(400)] == [False for x in range(400)]  # deleted entries
+        assert [HH(0, y, 0) in idx for y in range(400)] == [False for y in range(400)]  # deleted entries
 
         # this will fail at HH(600, 259) if the bug is present.
-        assert [idx.get(HH(600, x, 0, 0)) for x in range(330)] == [(600, x, 0, 0) for x in range(330)]
+        assert [idx.get(HH(600, y, 0)) for y in range(330)] == [(600, y, 0) for y in range(330)]
diff --git a/src/borg/testsuite/repository.py b/src/borg/testsuite/repository.py
index 180848c8e..a794f98ec 100644
--- a/src/borg/testsuite/repository.py
+++ b/src/borg/testsuite/repository.py
@@ -714,7 +714,7 @@ class RepositoryCheckTestCase(RepositoryTestCaseBase):
 
     def corrupt_object(self, id_):
         idx = self.open_index()
-        segment, offset, _, _ = idx[H(id_)]
+        segment, offset, _ = idx[H(id_)]
         with open(os.path.join(self.tmppath, 'repository', 'data', '0', str(segment)), 'r+b') as fd:
             fd.seek(offset)
             fd.write(b'BOOM')

From f9132687e35ce1d2f57ca04403a95c787b7cabfc Mon Sep 17 00:00:00 2001
From: Thomas Waldmann <tw@waldmann-edv.de>
Date: Tue, 14 Jun 2022 15:17:30 +0200
Subject: [PATCH 044/160] fix selftest count

---
 src/borg/selftest.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/borg/selftest.py b/src/borg/selftest.py
index 00356cd0e..1bef011c2 100644
--- a/src/borg/selftest.py
+++ b/src/borg/selftest.py
@@ -33,7 +33,7 @@ SELFTEST_CASES = [
     ChunkerTestCase,
 ]
 
-SELFTEST_COUNT = 37
+SELFTEST_COUNT = 38
 
 
 class SelfTestResult(TestResult):

From 72994a4432567e0b3f087066c87ac309f9d52540 Mon Sep 17 00:00:00 2001
From: Thomas Waldmann <tw@waldmann-edv.de>
Date: Tue, 14 Jun 2022 15:40:09 +0200
Subject: [PATCH 045/160] also test pull requests against borg2 branch

---
 .github/workflows/ci.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index cf14f2397..9f91adb7f 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -16,7 +16,7 @@ on:
     - 'requirements.d/*'
     - '!docs/**'
   pull_request:
-    branches: [ master ]
+    branches: [ master, borg2 ]
     paths:
     - '**.py'
     - '**.pyx'

From c01f3527e5b7fffbe3e7634c7486a126c99e67e7 Mon Sep 17 00:00:00 2001
From: Thomas Waldmann <tw@waldmann-edv.de>
Date: Tue, 14 Jun 2022 15:42:30 +0200
Subject: [PATCH 046/160] fix linter errors

---
 src/borg/archiver.py | 2 +-
 src/borg/cache.py    | 3 ---
 2 files changed, 1 insertion(+), 4 deletions(-)

diff --git a/src/borg/archiver.py b/src/borg/archiver.py
index 1a46e4350..c92ba7e05 100644
--- a/src/borg/archiver.py
+++ b/src/borg/archiver.py
@@ -1356,7 +1356,7 @@ class Archiver:
             tarinfo.uid = item.uid
             tarinfo.gid = item.gid
             tarinfo.uname = item.get('user', '')
-            tarinfo.gname = item.get('group',  '')
+            tarinfo.gname = item.get('group', '')
             # The linkname in tar has 2 uses:
             # for symlinks it means the destination, while for hardlinks it refers to the file.
             # Since hardlinks in tar have a different type code (LNKTYPE) the format might
diff --git a/src/borg/cache.py b/src/borg/cache.py
index 784910673..d5d87f74d 100644
--- a/src/borg/cache.py
+++ b/src/borg/cache.py
@@ -1,5 +1,4 @@
 import configparser
-import json
 import os
 import shutil
 import stat
@@ -655,8 +654,6 @@ class LocalCache(CacheStatsMixin):
         archive indexes.
         """
         archive_path = os.path.join(self.path, 'chunks.archive.d')
-        # An index of chunks whose size had to be fetched
-        chunks_fetched_size_index = ChunkIndex()
         # Instrumentation
         processed_item_metadata_bytes = 0
         processed_item_metadata_chunks = 0

From 1c707b7da20ab08bb93f637e64eb8af24c0b724c Mon Sep 17 00:00:00 2001
From: Thomas Waldmann <tw@waldmann-edv.de>
Date: Tue, 14 Jun 2022 00:28:47 +0200
Subject: [PATCH 047/160] cli: use --repo option instead of positional repo
 parameter

currently still with ::archive appended.
---
 src/borg/archiver.py           |  149 +--
 src/borg/testsuite/__init__.py |    2 +-
 src/borg/testsuite/archiver.py | 1643 ++++++++++++++++----------------
 3 files changed, 858 insertions(+), 936 deletions(-)

diff --git a/src/borg/archiver.py b/src/borg/archiver.py
index c92ba7e05..0e2d07855 100644
--- a/src/borg/archiver.py
+++ b/src/borg/archiver.py
@@ -664,34 +664,37 @@ class Archiver:
     def do_benchmark_crud(self, args):
         """Benchmark Create, Read, Update, Delete for archives."""
         def measurement_run(repo, path):
-            archive = repo + '::borg-benchmark-crud'
             compression = '--compression=none'
             # measure create perf (without files cache to always have it chunking)
             t_start = time.monotonic()
-            rc = self.do_create(self.parse_args(['create', compression, '--files-cache=disabled', archive + '1', path]))
+            rc = self.do_create(self.parse_args([f'--repo={repo}::borg-benchmark-crud1', 'create',
+                                                 compression, '--files-cache=disabled', path]))
             t_end = time.monotonic()
             dt_create = t_end - t_start
             assert rc == 0
             # now build files cache
-            rc1 = self.do_create(self.parse_args(['create', compression, archive + '2', path]))
-            rc2 = self.do_delete(self.parse_args(['delete', archive + '2']))
+            rc1 = self.do_create(self.parse_args([f'--repo={repo}::borg-benchmark-crud2', 'create',
+                                                  compression, path]))
+            rc2 = self.do_delete(self.parse_args([f'--repo={repo}::borg-benchmark-crud2', 'delete']))
             assert rc1 == rc2 == 0
             # measure a no-change update (archive1 is still present)
             t_start = time.monotonic()
-            rc1 = self.do_create(self.parse_args(['create', compression, archive + '3', path]))
+            rc1 = self.do_create(self.parse_args([f'--repo={repo}::borg-benchmark-crud3', 'create',
+                                                  compression, path]))
             t_end = time.monotonic()
             dt_update = t_end - t_start
-            rc2 = self.do_delete(self.parse_args(['delete', archive + '3']))
+            rc2 = self.do_delete(self.parse_args([f'--repo={repo}::borg-benchmark-crud3', 'delete']))
             assert rc1 == rc2 == 0
             # measure extraction (dry-run: without writing result to disk)
             t_start = time.monotonic()
-            rc = self.do_extract(self.parse_args(['extract', '--dry-run', archive + '1']))
+            rc = self.do_extract(self.parse_args([f'--repo={repo}::borg-benchmark-crud1', 'extract',
+                                                  '--dry-run']))
             t_end = time.monotonic()
             dt_extract = t_end - t_start
             assert rc == 0
             # measure archive deletion (of LAST present archive with the data)
             t_start = time.monotonic()
-            rc = self.do_delete(self.parse_args(['delete', archive + '1']))
+            rc = self.do_delete(self.parse_args([f'--repo={repo}::borg-benchmark-crud1', 'delete']))
             t_end = time.monotonic()
             dt_delete = t_end - t_start
             assert rc == 0
@@ -3200,6 +3203,8 @@ class Archiver:
                                    'compatible file can be generated by suffixing FILE with ".pyprof".')
             add_common_option('--rsh', metavar='RSH', dest='rsh',
                               help="Use this command to connect to the 'borg serve' process (default: 'ssh')")
+            add_common_option('--repo', metavar='REPO', dest='location', type=location_validator(),
+                              help="repository to use")  # XXXYYY
 
         def define_exclude_and_patterns(add_option, *, tag_files=False, strip_components=False):
             add_option('-e', '--exclude', metavar='PATTERN', dest='patterns',
@@ -3263,8 +3268,7 @@ class Archiver:
 
         def define_borg_mount(parser):
             parser.set_defaults(func=self.do_mount)
-            parser.add_argument('location', metavar='REPOSITORY_OR_ARCHIVE', type=location_validator(),
-                                help='repository or archive to mount')
+            # archive name
             parser.add_argument('--consider-checkpoints', action='store_true', dest='consider_checkpoints',
                                 help='Show checkpoint archives in the repository contents list (default: hidden).')
             parser.add_argument('mountpoint', metavar='MOUNTPOINT', type=str,
@@ -3427,10 +3431,6 @@ class Archiver:
                                                  help='benchmarks borg CRUD (create, extract, update, delete).')
         subparser.set_defaults(func=self.do_benchmark_crud)
 
-        subparser.add_argument('location', metavar='REPOSITORY',
-                               type=location_validator(archive=False),
-                               help='repository to use for benchmark (must exist)')
-
         subparser.add_argument('path', metavar='PATH', help='path were to create benchmark input data')
 
         bench_cpu_epilog = process_epilog("""
@@ -3460,9 +3460,6 @@ class Archiver:
                                           formatter_class=argparse.RawDescriptionHelpFormatter,
                                           help='break repository and cache locks')
         subparser.set_defaults(func=self.do_break_lock)
-        subparser.add_argument('location', metavar='REPOSITORY', nargs='?', default='',
-                               type=location_validator(archive=False),
-                               help='repository for which to break the locks')
 
         # borg check
         check_epilog = process_epilog("""
@@ -3545,9 +3542,7 @@ class Archiver:
                                           formatter_class=argparse.RawDescriptionHelpFormatter,
                                           help='verify repository')
         subparser.set_defaults(func=self.do_check)
-        subparser.add_argument('location', metavar='REPOSITORY_OR_ARCHIVE', nargs='?', default='',
-                               type=location_validator(),
-                               help='repository or archive to check consistency of')
+        # archive name
         subparser.add_argument('--repository-only', dest='repo_only', action='store_true',
                                help='only perform repository checks')
         subparser.add_argument('--archives-only', dest='archives_only', action='store_true',
@@ -3595,9 +3590,6 @@ class Archiver:
                                           formatter_class=argparse.RawDescriptionHelpFormatter,
                                           help='compact segment files / free space in repo')
         subparser.set_defaults(func=self.do_compact)
-        subparser.add_argument('location', metavar='REPOSITORY', nargs='?', default='',
-                               type=location_validator(archive=False),
-                               help='repository to compact')
         subparser.add_argument('--cleanup-commits', dest='cleanup_commits', action='store_true',
                                help='cleanup commit-only 17-byte segment files')
         subparser.add_argument('--threshold', metavar='PERCENT', dest='threshold',
@@ -3635,9 +3627,6 @@ class Archiver:
         group.add_argument('-l', '--list', dest='list', action='store_true',
                                help='list the configuration of the repo')
 
-        subparser.add_argument('location', metavar='REPOSITORY', nargs='?', default='',
-                               type=location_validator(archive=False, proto='file'),
-                               help='repository to configure')
         subparser.add_argument('name', metavar='NAME', nargs='?',
                                help='name of config key')
         subparser.add_argument('value', metavar='VALUE', nargs='?',
@@ -3921,9 +3910,7 @@ class Archiver:
                                    help='select compression algorithm, see the output of the '
                                         '"borg help compression" command for details.')
 
-        subparser.add_argument('location', metavar='ARCHIVE',
-                               type=location_validator(archive=True),
-                               help='name of archive to create (must be also a valid directory name)')
+        # archive name
         subparser.add_argument('paths', metavar='PATH', nargs='*', type=str,
                                help='paths to archive')
 
@@ -3966,9 +3953,7 @@ class Archiver:
                                           formatter_class=argparse.RawDescriptionHelpFormatter,
                                           help='dump archive items (metadata) (debug)')
         subparser.set_defaults(func=self.do_debug_dump_archive_items)
-        subparser.add_argument('location', metavar='ARCHIVE',
-                               type=location_validator(archive=True),
-                               help='archive to dump')
+        # archive name
 
         debug_dump_archive_epilog = process_epilog("""
         This command dumps all metadata of an archive in a decoded form to a file.
@@ -3979,9 +3964,7 @@ class Archiver:
                                           formatter_class=argparse.RawDescriptionHelpFormatter,
                                           help='dump decoded archive metadata (debug)')
         subparser.set_defaults(func=self.do_debug_dump_archive)
-        subparser.add_argument('location', metavar='ARCHIVE',
-                               type=location_validator(archive=True),
-                               help='archive to dump')
+        # archive name
         subparser.add_argument('path', metavar='PATH', type=str,
                                help='file to dump data into')
 
@@ -3994,9 +3977,6 @@ class Archiver:
                                           formatter_class=argparse.RawDescriptionHelpFormatter,
                                           help='dump decoded repository metadata (debug)')
         subparser.set_defaults(func=self.do_debug_dump_manifest)
-        subparser.add_argument('location', metavar='REPOSITORY',
-                               type=location_validator(archive=False),
-                               help='repository to dump')
         subparser.add_argument('path', metavar='PATH', type=str,
                                help='file to dump data into')
 
@@ -4009,9 +3989,6 @@ class Archiver:
                                           formatter_class=argparse.RawDescriptionHelpFormatter,
                                           help='dump repo objects (debug)')
         subparser.set_defaults(func=self.do_debug_dump_repo_objs)
-        subparser.add_argument('location', metavar='REPOSITORY',
-                               type=location_validator(archive=False),
-                               help='repository to dump')
         subparser.add_argument('--ghost', dest='ghost', action='store_true',
                                help='dump all segment file contents, including deleted/uncommitted objects and commits.')
 
@@ -4024,9 +4001,6 @@ class Archiver:
                                           formatter_class=argparse.RawDescriptionHelpFormatter,
                                           help='search repo objects (debug)')
         subparser.set_defaults(func=self.do_debug_search_repo_objs)
-        subparser.add_argument('location', metavar='REPOSITORY',
-                               type=location_validator(archive=False),
-                               help='repository to search')
         subparser.add_argument('wanted', metavar='WANTED', type=str,
                                help='term to search the repo for, either 0x1234abcd hex term or a string')
 
@@ -4039,9 +4013,6 @@ class Archiver:
                                           formatter_class=argparse.RawDescriptionHelpFormatter,
                                           help='get object from repository (debug)')
         subparser.set_defaults(func=self.do_debug_get_obj)
-        subparser.add_argument('location', metavar='REPOSITORY',
-                               type=location_validator(archive=False),
-                               help='repository to use')
         subparser.add_argument('id', metavar='ID', type=str,
                                help='hex object ID to get from the repo')
         subparser.add_argument('path', metavar='PATH', type=str,
@@ -4056,9 +4027,6 @@ class Archiver:
                                           formatter_class=argparse.RawDescriptionHelpFormatter,
                                           help='put object to repository (debug)')
         subparser.set_defaults(func=self.do_debug_put_obj)
-        subparser.add_argument('location', metavar='REPOSITORY',
-                               type=location_validator(archive=False),
-                               help='repository to use')
         subparser.add_argument('paths', metavar='PATH', nargs='+', type=str,
                                help='file(s) to read and create object(s) from')
 
@@ -4071,9 +4039,6 @@ class Archiver:
                                           formatter_class=argparse.RawDescriptionHelpFormatter,
                                           help='delete object from repository (debug)')
         subparser.set_defaults(func=self.do_debug_delete_obj)
-        subparser.add_argument('location', metavar='REPOSITORY',
-                               type=location_validator(archive=False),
-                               help='repository to use')
         subparser.add_argument('ids', metavar='IDs', nargs='+', type=str,
                                help='hex object ID(s) to delete from the repo')
 
@@ -4086,9 +4051,6 @@ class Archiver:
                                           formatter_class=argparse.RawDescriptionHelpFormatter,
                                           help='show refcount for object from repository (debug)')
         subparser.set_defaults(func=self.do_debug_refcount_obj)
-        subparser.add_argument('location', metavar='REPOSITORY',
-                               type=location_validator(archive=False),
-                               help='repository to use')
         subparser.add_argument('ids', metavar='IDs', nargs='+', type=str,
                                help='hex object ID(s) to show refcounts for')
 
@@ -4101,9 +4063,6 @@ class Archiver:
                                           formatter_class=argparse.RawDescriptionHelpFormatter,
                                           help='dump repo hints (debug)')
         subparser.set_defaults(func=self.do_debug_dump_hints)
-        subparser.add_argument('location', metavar='REPOSITORY',
-                               type=location_validator(archive=False),
-                               help='repository to dump')
         subparser.add_argument('path', metavar='PATH', type=str,
                                help='file to dump data into')
 
@@ -4171,9 +4130,7 @@ class Archiver:
                                help='keep the local security info when deleting a repository')
         subparser.add_argument('--save-space', dest='save_space', action='store_true',
                                help='work slower, but using less space')
-        subparser.add_argument('location', metavar='REPOSITORY_OR_ARCHIVE', nargs='?', default='',
-                               type=location_validator(),
-                               help='repository or archive to delete')
+        # archive name
         subparser.add_argument('archives', metavar='ARCHIVE', nargs='*',
                                help='archives to delete')
         define_archive_filters_group(subparser)
@@ -4210,9 +4167,9 @@ class Archiver:
         subparser.add_argument('other_location', metavar='SRC_REPOSITORY',
                                type=location_validator(archive=False, other=True),
                                help='source repository')
-        subparser.add_argument('location', metavar='DST_REPOSITORY',
-                               type=location_validator(archive=False, other=False),
-                               help='destination repository')
+        # subparser.add_argument('-r', '--repo', dest='location', metavar='DST_REPOSITORY',
+        #                        type=location_validator(archive=False, other=False),
+        #                        help='destination repository')
         define_archive_filters_group(subparser)
 
         # borg diff
@@ -4250,12 +4207,12 @@ class Archiver:
                                help='Sort the output lines by file path.')
         subparser.add_argument('--json-lines', action='store_true',
                                help='Format output as JSON Lines. ')
-        subparser.add_argument('location', metavar='REPO::ARCHIVE1',
-                               type=location_validator(archive=True),
-                               help='repository location and ARCHIVE1 name')
+        subparser.add_argument('archive1', metavar='ARCHIVE1',
+                               type=archivename_validator(),
+                               help='ARCHIVE1 name')
         subparser.add_argument('archive2', metavar='ARCHIVE2',
                                type=archivename_validator(),
-                               help='ARCHIVE2 name (no repository location allowed)')
+                               help='ARCHIVE2 name')
         subparser.add_argument('paths', metavar='PATH', nargs='*', type=str,
                                help='paths of items inside the archives to compare; patterns are supported')
         define_exclusion_group(subparser)
@@ -4317,9 +4274,7 @@ class Archiver:
         subparser.add_argument('--tar-format', metavar='FMT', dest='tar_format', default='GNU',
                                choices=('BORG', 'PAX', 'GNU'),
                                help='select tar format: BORG, PAX or GNU')
-        subparser.add_argument('location', metavar='ARCHIVE',
-                               type=location_validator(archive=True),
-                               help='archive to export')
+        # archive name
         subparser.add_argument('tarfile', metavar='FILE',
                                help='output tar file. "-" to write to stdout instead.')
         subparser.add_argument('paths', metavar='PATH', nargs='*', type=str,
@@ -4377,9 +4332,7 @@ class Archiver:
                                help='write all extracted data to stdout')
         subparser.add_argument('--sparse', dest='sparse', action='store_true',
                                help='create holes in output sparse file from all-zero chunks')
-        subparser.add_argument('location', metavar='ARCHIVE',
-                               type=location_validator(archive=True),
-                               help='archive to extract')
+        # archive name
         subparser.add_argument('paths', metavar='PATH', nargs='*', type=str,
                                help='paths to extract; patterns are supported')
         define_exclusion_group(subparser, strip_components=True)
@@ -4417,9 +4370,7 @@ class Archiver:
                                           formatter_class=argparse.RawDescriptionHelpFormatter,
                                           help='show repository or archive information')
         subparser.set_defaults(func=self.do_info)
-        subparser.add_argument('location', metavar='REPOSITORY_OR_ARCHIVE', nargs='?', default='',
-                               type=location_validator(),
-                               help='repository or archive to display information about')
+        # archive name
         subparser.add_argument('--json', action='store_true',
                                help='format output as JSON')
         define_archive_filters_group(subparser)
@@ -4553,9 +4504,6 @@ class Archiver:
                                           formatter_class=argparse.RawDescriptionHelpFormatter,
                                           help='initialize empty repository')
         subparser.set_defaults(func=self.do_init)
-        subparser.add_argument('location', metavar='REPOSITORY', nargs='?', default='',
-                               type=location_validator(archive=False),
-                               help='repository to create')
         subparser.add_argument('--other-location', metavar='OTHER_REPOSITORY', dest='other_location',
                                type=location_validator(archive=False, other=True),
                                help='reuse the key material from the other repository')
@@ -4626,8 +4574,6 @@ class Archiver:
                                           formatter_class=argparse.RawDescriptionHelpFormatter,
                                           help='export repository key for backup')
         subparser.set_defaults(func=self.do_key_export)
-        subparser.add_argument('location', metavar='REPOSITORY', nargs='?', default='',
-                               type=location_validator(archive=False))
         subparser.add_argument('path', metavar='PATH', nargs='?', type=str,
                                help='where to store the backup')
         subparser.add_argument('--paper', dest='paper', action='store_true',
@@ -4657,8 +4603,6 @@ class Archiver:
                                           formatter_class=argparse.RawDescriptionHelpFormatter,
                                           help='import repository key from backup')
         subparser.set_defaults(func=self.do_key_import)
-        subparser.add_argument('location', metavar='REPOSITORY', nargs='?', default='',
-                               type=location_validator(archive=False))
         subparser.add_argument('path', metavar='PATH', nargs='?', type=str,
                                help='path to the backup (\'-\' to read from stdin)')
         subparser.add_argument('--paper', dest='paper', action='store_true',
@@ -4679,8 +4623,6 @@ class Archiver:
                                           formatter_class=argparse.RawDescriptionHelpFormatter,
                                           help='change repository passphrase')
         subparser.set_defaults(func=self.do_change_passphrase)
-        subparser.add_argument('location', metavar='REPOSITORY', nargs='?', default='',
-                               type=location_validator(archive=False))
 
         change_location_epilog = process_epilog("""
         Change the location of a borg key. The key can be stored at different locations:
@@ -4697,8 +4639,6 @@ class Archiver:
                                           formatter_class=argparse.RawDescriptionHelpFormatter,
                                           help='change key location')
         subparser.set_defaults(func=self.do_change_location)
-        subparser.add_argument('location', metavar='REPOSITORY', nargs='?', default='',
-                               type=location_validator(archive=False))
         subparser.add_argument('key_mode', metavar='KEY_LOCATION', choices=('repokey', 'keyfile'),
                                help='select key location')
         subparser.add_argument('--keep', dest='keep', action='store_true',
@@ -4741,8 +4681,6 @@ class Archiver:
                                            formatter_class=argparse.RawDescriptionHelpFormatter,
                                            help='change key algorithm')
         subparser.set_defaults(func=self.do_change_algorithm)
-        subparser.add_argument('location', metavar='REPOSITORY', nargs='?', default='',
-                               type=location_validator(archive=False))
         subparser.add_argument('algorithm', metavar='ALGORITHM', choices=list(KEY_ALGORITHMS),
                                help='select key algorithm')
 
@@ -4821,9 +4759,7 @@ class Archiver:
                                     'but keys used in it are added to the JSON output. '
                                     'Some keys are always present. Note: JSON can only represent text. '
                                     'A "bpath" key is therefore not available.')
-        subparser.add_argument('location', metavar='REPOSITORY_OR_ARCHIVE', nargs='?', default='',
-                               type=location_validator(),
-                               help='repository or archive to list contents of')
+        # archive name
         subparser.add_argument('paths', metavar='PATH', nargs='*', type=str,
                                help='paths to list; patterns are supported')
         define_archive_filters_group(subparser)
@@ -4926,9 +4862,6 @@ class Archiver:
         define_archive_filters_group(subparser, sort_by=False, first_last=False)
         subparser.add_argument('--save-space', dest='save_space', action='store_true',
                                help='work slower, but using less space')
-        subparser.add_argument('location', metavar='REPOSITORY', nargs='?', default='',
-                               type=location_validator(archive=False),
-                               help='repository to prune')
 
         # borg recreate
         recreate_epilog = process_epilog("""
@@ -5036,9 +4969,7 @@ class Archiver:
                                         'HASH_MASK_BITS, HASH_WINDOW_SIZE) or `default` to use the current defaults. '
                                         'default: %s,%d,%d,%d,%d' % CHUNKER_PARAMS)
 
-        subparser.add_argument('location', metavar='REPOSITORY_OR_ARCHIVE', nargs='?', default='',
-                               type=location_validator(),
-                               help='repository or archive to recreate')
+        # archive name
         subparser.add_argument('paths', metavar='PATH', nargs='*', type=str,
                                help='paths to recreate; patterns are supported')
 
@@ -5054,12 +4985,12 @@ class Archiver:
                                           formatter_class=argparse.RawDescriptionHelpFormatter,
                                           help='rename archive')
         subparser.set_defaults(func=self.do_rename)
-        subparser.add_argument('location', metavar='ARCHIVE',
-                               type=location_validator(archive=True),
-                               help='archive to rename')
+        subparser.add_argument('name_current', metavar='OLDNAME',
+                               type=archivename_validator(),
+                               help='the current archive name')
         subparser.add_argument('name', metavar='NEWNAME',
                                type=archivename_validator(),
-                               help='the new archive name to use')
+                               help='the new archive name')
 
         # borg serve
         serve_epilog = process_epilog("""
@@ -5176,9 +5107,6 @@ class Archiver:
                                help='Enable manifest authentication (in key and cache) (Borg 1.0.9 and later).')
         subparser.add_argument('--disable-tam', dest='disable_tam', action='store_true',
                                help='Disable manifest authentication (in key and cache).')
-        subparser.add_argument('location', metavar='REPOSITORY', nargs='?', default='',
-                               type=location_validator(archive=False),
-                               help='path to the repository to be upgraded')
 
         # borg with-lock
         with_lock_epilog = process_epilog("""
@@ -5202,9 +5130,6 @@ class Archiver:
                                           formatter_class=argparse.RawDescriptionHelpFormatter,
                                           help='run user command with lock held')
         subparser.set_defaults(func=self.do_with_lock)
-        subparser.add_argument('location', metavar='REPOSITORY',
-                               type=location_validator(archive=False),
-                               help='repository to lock')
         subparser.add_argument('command', metavar='COMMAND',
                                help='command to run')
         subparser.add_argument('args', metavar='ARGS', nargs=argparse.REMAINDER,
@@ -5286,9 +5211,7 @@ class Archiver:
                                    help='select compression algorithm, see the output of the '
                                         '"borg help compression" command for details.')
 
-        subparser.add_argument('location', metavar='ARCHIVE',
-                               type=location_validator(archive=True),
-                               help='name of archive to create (must be also a valid directory name)')
+        # archive name
         subparser.add_argument('tarfile', metavar='TARFILE',
                                help='input tar file. "-" to read from stdin instead.')
         return parser
diff --git a/src/borg/testsuite/__init__.py b/src/borg/testsuite/__init__.py
index b1db8aa95..307798e64 100644
--- a/src/borg/testsuite/__init__.py
+++ b/src/borg/testsuite/__init__.py
@@ -248,7 +248,7 @@ class BaseTestCase(unittest.TestCase):
             mountpoint = tempfile.mkdtemp()
         else:
             os.mkdir(mountpoint)
-        args = ['mount', location, mountpoint] + list(options)
+        args = [f'--repo={location}', 'mount', mountpoint] + list(options)
         if os_fork:
             # Do not spawn, but actually (OS) fork.
             if os.fork() == 0:
diff --git a/src/borg/testsuite/archiver.py b/src/borg/testsuite/archiver.py
index e033d6cf7..1c67a5573 100644
--- a/src/borg/testsuite/archiver.py
+++ b/src/borg/testsuite/archiver.py
@@ -147,16 +147,16 @@ def test_return_codes(cmd, tmpdir):
     input = tmpdir.mkdir('input')
     output = tmpdir.mkdir('output')
     input.join('test_file').write('content')
-    rc, out = cmd('init', '--encryption=none', '%s' % str(repo))
+    rc, out = cmd('--repo=%s' % str(repo), 'init', '--encryption=none')
     assert rc == EXIT_SUCCESS
-    rc, out = cmd('create', '%s::archive' % repo, str(input))
+    rc, out = cmd('--repo=%s::archive' % repo, 'create', str(input))
     assert rc == EXIT_SUCCESS
     with changedir(str(output)):
-        rc, out = cmd('extract', '%s::archive' % repo)
+        rc, out = cmd('--repo=%s::archive' % repo, 'extract')
         assert rc == EXIT_SUCCESS
-    rc, out = cmd('extract', '%s::archive' % repo, 'does/not/match')
+    rc, out = cmd('--repo=%s::archive' % repo, 'extract', 'does/not/match')
     assert rc == EXIT_WARNING  # pattern did not match
-    rc, out = cmd('create', '%s::archive' % repo, str(input))
+    rc, out = cmd('--repo=%s::archive' % repo, 'create', str(input))
     assert rc == EXIT_ERROR  # duplicate archive name
 
 
@@ -203,7 +203,7 @@ def test_disk_full(cmd):
             shutil.rmtree(input, ignore_errors=True)
             # keep some space and some inodes in reserve that we can free up later:
             make_files(reserve, 80, 100000, rnd=False)
-            rc, out = cmd('init', repo)
+            rc, out = cmd(f'--repo={repo}', 'init')
             if rc != EXIT_SUCCESS:
                 print('init', rc, out)
             assert rc == EXIT_SUCCESS
@@ -219,7 +219,7 @@ def test_disk_full(cmd):
                             break
                         raise
                     try:
-                        rc, out = cmd('create', '%s::test%03d' % (repo, i), input)
+                        rc, out = cmd('--repo=%s::test%03d' % (repo, i), 'create', input)
                         success = rc == EXIT_SUCCESS
                         if not success:
                             print('create', rc, out)
@@ -231,10 +231,10 @@ def test_disk_full(cmd):
                 # now some error happened, likely we are out of disk space.
                 # free some space so we can expect borg to be able to work normally:
                 shutil.rmtree(reserve, ignore_errors=True)
-            rc, out = cmd('list', repo)
+            rc, out = cmd(f'--repo={repo}', 'list')
             if rc != EXIT_SUCCESS:
                 print('list', rc, out)
-            rc, out = cmd('check', '--repair', repo)
+            rc, out = cmd(f'--repo={repo}', 'check', '--repair')
             if rc != EXIT_SUCCESS:
                 print('check', rc, out)
             assert rc == EXIT_SUCCESS
@@ -299,7 +299,7 @@ class ArchiverTestCaseBase(BaseTestCase):
         return output
 
     def create_src_archive(self, name):
-        self.cmd('create', '--compression=lz4', self.repository_location + '::' + name, src_dir)
+        self.cmd(f'--repo={self.repository_location}::{name}', 'create', '--compression=lz4', src_dir)
 
     def open_archive(self, name):
         repository = Repository(self.repository_path, exclusive=True)
@@ -391,16 +391,16 @@ class ArchiverTestCase(ArchiverTestCaseBase):
     def test_basic_functionality(self):
         have_root = self.create_test_files()
         # fork required to test show-rc output
-        output = self.cmd('init', '--encryption=repokey', '--show-version', '--show-rc', self.repository_location, fork=True)
+        output = self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey', '--show-version', '--show-rc', fork=True)
         self.assert_in('borgbackup version', output)
         self.assert_in('terminating with success status, rc 0', output)
-        self.cmd('create', '--exclude-nodump', self.repository_location + '::test', 'input')
-        output = self.cmd('create', '--exclude-nodump', '--stats', self.repository_location + '::test.2', 'input')
+        self.cmd(f'--repo={self.repository_location}::test', 'create', '--exclude-nodump', 'input')
+        output = self.cmd(f'--repo={self.repository_location}::test.2', 'create', '--exclude-nodump', '--stats', 'input')
         self.assert_in('Archive name: test.2', output)
         self.assert_in('This archive: ', output)
         with changedir('output'):
-            self.cmd('extract', self.repository_location + '::test')
-        list_output = self.cmd('list', '--short', self.repository_location)
+            self.cmd(f'--repo={self.repository_location}::test', 'extract')
+        list_output = self.cmd(f'--repo={self.repository_location}', 'list', '--short')
         self.assert_in('test', list_output)
         self.assert_in('test.2', list_output)
         expected = [
@@ -427,15 +427,15 @@ class ArchiverTestCase(ArchiverTestCaseBase):
             # remove the file we did not backup, so input and output become equal
             expected.remove('input/flagfile')  # this file is UF_NODUMP
             os.remove(os.path.join('input', 'flagfile'))
-        list_output = self.cmd('list', '--short', self.repository_location + '::test')
+        list_output = self.cmd(f'--repo={self.repository_location}::test', 'list', '--short')
         for name in expected:
             self.assert_in(name, list_output)
         self.assert_dirs_equal('input', 'output/input')
-        info_output = self.cmd('info', self.repository_location + '::test')
+        info_output = self.cmd(f'--repo={self.repository_location}::test', 'info')
         item_count = 5 if has_lchflags else 6  # one file is UF_NODUMP
         self.assert_in('Number of files: %d' % item_count, info_output)
         shutil.rmtree(self.cache_path)
-        info_output2 = self.cmd('info', self.repository_location + '::test')
+        info_output2 = self.cmd(f'--repo={self.repository_location}::test', 'info')
 
         def filter(output):
             # filter for interesting "info" output, ignore cache rebuilding related stuff
@@ -462,10 +462,10 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         hl_b = os.path.join(path_b, 'hardlink')
         self.create_regular_file(hl_a, contents=b'123456')
         os.link(hl_a, hl_b)
-        self.cmd('init', '--encryption=none', self.repository_location)
-        self.cmd('create', self.repository_location + '::test', 'input', 'input')  # give input twice!
+        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=none')
+        self.cmd(f'--repo={self.repository_location}::test', 'create', 'input', 'input')  # give input twice!
         # test if created archive has 'input' contents twice:
-        archive_list = self.cmd('list', '--json-lines', self.repository_location + '::test')
+        archive_list = self.cmd(f'--repo={self.repository_location}::test', 'list', '--json-lines')
         paths = [json.loads(line)['path'] for line in archive_list.split('\n') if line]
         # we have all fs items exactly once!
         assert sorted(paths) == ['input', 'input/a', 'input/a/hardlink', 'input/b', 'input/b/hardlink']
@@ -476,13 +476,13 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         repository_location = self.prefix + repository_path
         with pytest.raises(Repository.ParentPathDoesNotExist):
             # normal borg init does NOT create missing parent dirs
-            self.cmd('init', '--encryption=none', repository_location)
+            self.cmd(f'--repo={repository_location}', 'init', '--encryption=none')
         # but if told so, it does:
-        self.cmd('init', '--encryption=none', '--make-parent-dirs', repository_location)
+        self.cmd(f'--repo={repository_location}', 'init', '--encryption=none', '--make-parent-dirs')
         assert os.path.exists(parent_path)
 
     def test_unix_socket(self):
-        self.cmd('init', '--encryption=repokey', self.repository_location)
+        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
         try:
             sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
             sock.bind(os.path.join(self.input_path, 'unix-socket'))
@@ -491,19 +491,19 @@ class ArchiverTestCase(ArchiverTestCaseBase):
                 pytest.skip('unix sockets disabled or not supported')
             elif err.errno == errno.EACCES:
                 pytest.skip('permission denied to create unix sockets')
-        self.cmd('create', self.repository_location + '::test', 'input')
+        self.cmd(f'--repo={self.repository_location}::test', 'create', 'input')
         sock.close()
         with changedir('output'):
-            self.cmd('extract', self.repository_location + '::test')
+            self.cmd(f'--repo={self.repository_location}::test', 'extract')
             assert not os.path.exists('input/unix-socket')
 
     @pytest.mark.skipif(not are_symlinks_supported(), reason='symlinks not supported')
     def test_symlink_extract(self):
         self.create_test_files()
-        self.cmd('init', '--encryption=repokey', self.repository_location)
-        self.cmd('create', self.repository_location + '::test', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}::test', 'create', 'input')
         with changedir('output'):
-            self.cmd('extract', self.repository_location + '::test')
+            self.cmd(f'--repo={self.repository_location}::test', 'extract')
             assert os.readlink('input/link1') == 'somewhere'
 
     @pytest.mark.skipif(not are_symlinks_supported() or not are_hardlinks_supported(),
@@ -513,10 +513,10 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         with changedir('input'):
             os.symlink('target', 'symlink1')
             os.link('symlink1', 'symlink2', follow_symlinks=False)
-        self.cmd('init', '--encryption=repokey', self.repository_location)
-        self.cmd('create', self.repository_location + '::test', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}::test', 'create', 'input')
         with changedir('output'):
-            output = self.cmd('extract', self.repository_location + '::test')
+            output = self.cmd(f'--repo={self.repository_location}::test', 'extract')
             print(output)
             with changedir('input'):
                 assert os.path.exists('target')
@@ -547,10 +547,10 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         atime, mtime = 123456780, 234567890
         have_noatime = has_noatime('input/file1')
         os.utime('input/file1', (atime, mtime))
-        self.cmd('init', '--encryption=repokey', self.repository_location)
-        self.cmd('create', '--atime', self.repository_location + '::test', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}::test', 'create', '--atime', 'input')
         with changedir('output'):
-            self.cmd('extract', self.repository_location + '::test')
+            self.cmd(f'--repo={self.repository_location}::test', 'extract')
         sti = os.stat('input/file1')
         sto = os.stat('output/input/file1')
         assert sti.st_mtime_ns == sto.st_mtime_ns == mtime * 1e9
@@ -567,10 +567,10 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         birthtime, mtime, atime = 946598400, 946684800, 946771200
         os.utime('input/file1', (atime, birthtime))
         os.utime('input/file1', (atime, mtime))
-        self.cmd('init', '--encryption=repokey', self.repository_location)
-        self.cmd('create', self.repository_location + '::test', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}::test', 'create', 'input')
         with changedir('output'):
-            self.cmd('extract', self.repository_location + '::test')
+            self.cmd(f'--repo={self.repository_location}::test', 'extract')
         sti = os.stat('input/file1')
         sto = os.stat('output/input/file1')
         assert int(sti.st_birthtime * 1e9) == int(sto.st_birthtime * 1e9) == birthtime * 1e9
@@ -583,10 +583,10 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         birthtime, mtime, atime = 946598400, 946684800, 946771200
         os.utime('input/file1', (atime, birthtime))
         os.utime('input/file1', (atime, mtime))
-        self.cmd('init', '--encryption=repokey', self.repository_location)
-        self.cmd('create', '--nobirthtime', self.repository_location + '::test', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}::test', 'create', '--nobirthtime', 'input')
         with changedir('output'):
-            self.cmd('extract', self.repository_location + '::test')
+            self.cmd(f'--repo={self.repository_location}::test', 'extract')
         sti = os.stat('input/file1')
         sto = os.stat('output/input/file1')
         assert int(sti.st_birthtime * 1e9) == birthtime * 1e9
@@ -644,10 +644,10 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         if sparse_support:
             # we could create a sparse input file, so creating a backup of it and
             # extracting it again (as sparse) should also work:
-            self.cmd('init', '--encryption=repokey', self.repository_location)
-            self.cmd('create', self.repository_location + '::test', 'input')
+            self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+            self.cmd(f'--repo={self.repository_location}::test', 'create', 'input')
             with changedir(self.output_path):
-                self.cmd('extract', '--sparse', self.repository_location + '::test')
+                self.cmd(f'--repo={self.repository_location}::test', 'extract', '--sparse')
             self.assert_dirs_equal('input', 'output/input')
             filename = os.path.join(self.output_path, 'input', 'sparse')
             with open(filename, 'rb') as fd:
@@ -663,158 +663,158 @@ class ArchiverTestCase(ArchiverTestCaseBase):
             filename = os.path.join(self.input_path, filename)
             with open(filename, 'wb'):
                 pass
-        self.cmd('init', '--encryption=repokey', self.repository_location)
-        self.cmd('create', self.repository_location + '::test', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}::test', 'create', 'input')
         for filename in filenames:
             with changedir('output'):
-                self.cmd('extract', self.repository_location + '::test', os.path.join('input', filename))
+                self.cmd(f'--repo={self.repository_location}::test', 'extract', os.path.join('input', filename))
             assert os.path.exists(os.path.join('output', 'input', filename))
 
     def test_repository_swap_detection(self):
         self.create_test_files()
         os.environ['BORG_PASSPHRASE'] = 'passphrase'
-        self.cmd('init', '--encryption=repokey', self.repository_location)
+        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
         repository_id = self._extract_repository_id(self.repository_path)
-        self.cmd('create', self.repository_location + '::test', 'input')
+        self.cmd(f'--repo={self.repository_location}::test', 'create', 'input')
         shutil.rmtree(self.repository_path)
-        self.cmd('init', '--encryption=none', self.repository_location)
+        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=none')
         self._set_repository_id(self.repository_path, repository_id)
         self.assert_equal(repository_id, self._extract_repository_id(self.repository_path))
         if self.FORK_DEFAULT:
-            self.cmd('create', self.repository_location + '::test.2', 'input', exit_code=EXIT_ERROR)
+            self.cmd(f'--repo={self.repository_location}::test.2', 'create', 'input', exit_code=EXIT_ERROR)
         else:
             with pytest.raises(Cache.EncryptionMethodMismatch):
-                self.cmd('create', self.repository_location + '::test.2', 'input')
+                self.cmd(f'--repo={self.repository_location}::test.2', 'create', 'input')
 
     def test_repository_swap_detection2(self):
         self.create_test_files()
-        self.cmd('init', '--encryption=none', self.repository_location + '_unencrypted')
+        self.cmd(f'--repo={self.repository_location}_unencrypted', 'init', '--encryption=none')
         os.environ['BORG_PASSPHRASE'] = 'passphrase'
-        self.cmd('init', '--encryption=repokey', self.repository_location + '_encrypted')
-        self.cmd('create', self.repository_location + '_encrypted::test', 'input')
+        self.cmd(f'--repo={self.repository_location}_encrypted', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}_encrypted::test', 'create', 'input')
         shutil.rmtree(self.repository_path + '_encrypted')
         os.rename(self.repository_path + '_unencrypted', self.repository_path + '_encrypted')
         if self.FORK_DEFAULT:
-            self.cmd('create', self.repository_location + '_encrypted::test.2', 'input', exit_code=EXIT_ERROR)
+            self.cmd(f'--repo={self.repository_location}_encrypted::test.2', 'create', 'input', exit_code=EXIT_ERROR)
         else:
             with pytest.raises(Cache.RepositoryAccessAborted):
-                self.cmd('create', self.repository_location + '_encrypted::test.2', 'input')
+                self.cmd(f'--repo={self.repository_location}_encrypted::test.2', 'create', 'input')
 
     def test_repository_swap_detection_no_cache(self):
         self.create_test_files()
         os.environ['BORG_PASSPHRASE'] = 'passphrase'
-        self.cmd('init', '--encryption=repokey', self.repository_location)
+        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
         repository_id = self._extract_repository_id(self.repository_path)
-        self.cmd('create', self.repository_location + '::test', 'input')
+        self.cmd(f'--repo={self.repository_location}::test', 'create', 'input')
         shutil.rmtree(self.repository_path)
-        self.cmd('init', '--encryption=none', self.repository_location)
+        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=none')
         self._set_repository_id(self.repository_path, repository_id)
         self.assert_equal(repository_id, self._extract_repository_id(self.repository_path))
-        self.cmd('delete', '--cache-only', self.repository_location)
+        self.cmd(f'--repo={self.repository_location}', 'delete', '--cache-only')
         if self.FORK_DEFAULT:
-            self.cmd('create', self.repository_location + '::test.2', 'input', exit_code=EXIT_ERROR)
+            self.cmd(f'--repo={self.repository_location}::test.2', 'create', 'input', exit_code=EXIT_ERROR)
         else:
             with pytest.raises(Cache.EncryptionMethodMismatch):
-                self.cmd('create', self.repository_location + '::test.2', 'input')
+                self.cmd(f'--repo={self.repository_location}::test.2', 'create', 'input')
 
     def test_repository_swap_detection2_no_cache(self):
         self.create_test_files()
-        self.cmd('init', '--encryption=none', self.repository_location + '_unencrypted')
+        self.cmd(f'--repo={self.repository_location}_unencrypted', 'init', '--encryption=none')
         os.environ['BORG_PASSPHRASE'] = 'passphrase'
-        self.cmd('init', '--encryption=repokey', self.repository_location + '_encrypted')
-        self.cmd('create', self.repository_location + '_encrypted::test', 'input')
-        self.cmd('delete', '--cache-only', self.repository_location + '_unencrypted')
-        self.cmd('delete', '--cache-only', self.repository_location + '_encrypted')
+        self.cmd(f'--repo={self.repository_location}_encrypted', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}_encrypted::test', 'create', 'input')
+        self.cmd(f'--repo={self.repository_location}_unencrypted', 'delete', '--cache-only')
+        self.cmd(f'--repo={self.repository_location}_encrypted', 'delete', '--cache-only')
         shutil.rmtree(self.repository_path + '_encrypted')
         os.rename(self.repository_path + '_unencrypted', self.repository_path + '_encrypted')
         if self.FORK_DEFAULT:
-            self.cmd('create', self.repository_location + '_encrypted::test.2', 'input', exit_code=EXIT_ERROR)
+            self.cmd(f'--repo={self.repository_location}_encrypted::test.2', 'create', 'input', exit_code=EXIT_ERROR)
         else:
             with pytest.raises(Cache.RepositoryAccessAborted):
-                self.cmd('create', self.repository_location + '_encrypted::test.2', 'input')
+                self.cmd(f'--repo={self.repository_location}_encrypted::test.2', 'create', 'input')
 
     def test_repository_swap_detection_repokey_blank_passphrase(self):
         # Check that a repokey repo with a blank passphrase is considered like a plaintext repo.
         self.create_test_files()
         # User initializes her repository with her passphrase
-        self.cmd('init', '--encryption=repokey', self.repository_location)
-        self.cmd('create', self.repository_location + '::test', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}::test', 'create', 'input')
         # Attacker replaces it with her own repository, which is encrypted but has no passphrase set
         shutil.rmtree(self.repository_path)
         with environment_variable(BORG_PASSPHRASE=''):
-            self.cmd('init', '--encryption=repokey', self.repository_location)
+            self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
             # Delete cache & security database, AKA switch to user perspective
-            self.cmd('delete', '--cache-only', self.repository_location)
+            self.cmd(f'--repo={self.repository_location}', 'delete', '--cache-only')
             shutil.rmtree(self.get_security_dir())
         with environment_variable(BORG_PASSPHRASE=None):
             # This is the part were the user would be tricked, e.g. she assumes that BORG_PASSPHRASE
             # is set, while it isn't. Previously this raised no warning,
             # since the repository is, technically, encrypted.
             if self.FORK_DEFAULT:
-                self.cmd('create', self.repository_location + '::test.2', 'input', exit_code=EXIT_ERROR)
+                self.cmd(f'--repo={self.repository_location}::test.2', 'create', 'input', exit_code=EXIT_ERROR)
             else:
                 with pytest.raises(Cache.CacheInitAbortedError):
-                    self.cmd('create', self.repository_location + '::test.2', 'input')
+                    self.cmd(f'--repo={self.repository_location}::test.2', 'create', 'input')
 
     def test_repository_move(self):
-        self.cmd('init', '--encryption=repokey', self.repository_location)
+        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
         security_dir = self.get_security_dir()
         os.rename(self.repository_path, self.repository_path + '_new')
         with environment_variable(BORG_RELOCATED_REPO_ACCESS_IS_OK='yes'):
-            self.cmd('info', self.repository_location + '_new')
+            self.cmd(f'--repo={self.repository_location}_new', 'info')
         with open(os.path.join(security_dir, 'location')) as fd:
             location = fd.read()
             assert location == Location(self.repository_location + '_new').canonical_path()
         # Needs no confirmation anymore
-        self.cmd('info', self.repository_location + '_new')
+        self.cmd(f'--repo={self.repository_location}_new', 'info')
         shutil.rmtree(self.cache_path)
-        self.cmd('info', self.repository_location + '_new')
+        self.cmd(f'--repo={self.repository_location}_new', 'info')
         shutil.rmtree(security_dir)
-        self.cmd('info', self.repository_location + '_new')
+        self.cmd(f'--repo={self.repository_location}_new', 'info')
         for file in ('location', 'key-type', 'manifest-timestamp'):
             assert os.path.exists(os.path.join(security_dir, file))
 
     def test_security_dir_compat(self):
-        self.cmd('init', '--encryption=repokey', self.repository_location)
+        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
         with open(os.path.join(self.get_security_dir(), 'location'), 'w') as fd:
             fd.write('something outdated')
         # This is fine, because the cache still has the correct information. security_dir and cache can disagree
         # if older versions are used to confirm a renamed repository.
-        self.cmd('info', self.repository_location)
+        self.cmd(f'--repo={self.repository_location}', 'info')
 
     def test_unknown_unencrypted(self):
-        self.cmd('init', '--encryption=none', self.repository_location)
+        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=none')
         # Ok: repository is known
-        self.cmd('info', self.repository_location)
+        self.cmd(f'--repo={self.repository_location}', 'info')
 
         # Ok: repository is still known (through security_dir)
         shutil.rmtree(self.cache_path)
-        self.cmd('info', self.repository_location)
+        self.cmd(f'--repo={self.repository_location}', 'info')
 
         # Needs confirmation: cache and security dir both gone (eg. another host or rm -rf ~)
         shutil.rmtree(self.cache_path)
         shutil.rmtree(self.get_security_dir())
         if self.FORK_DEFAULT:
-            self.cmd('info', self.repository_location, exit_code=EXIT_ERROR)
+            self.cmd(f'--repo={self.repository_location}', 'info', exit_code=EXIT_ERROR)
         else:
             with pytest.raises(Cache.CacheInitAbortedError):
-                self.cmd('info', self.repository_location)
+                self.cmd(f'--repo={self.repository_location}', 'info')
         with environment_variable(BORG_UNKNOWN_UNENCRYPTED_REPO_ACCESS_IS_OK='yes'):
-            self.cmd('info', self.repository_location)
+            self.cmd(f'--repo={self.repository_location}', 'info')
 
     def test_strip_components(self):
-        self.cmd('init', '--encryption=repokey', self.repository_location)
+        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
         self.create_regular_file('dir/file')
-        self.cmd('create', self.repository_location + '::test', 'input')
+        self.cmd(f'--repo={self.repository_location}::test', 'create', 'input')
         with changedir('output'):
-            self.cmd('extract', self.repository_location + '::test', '--strip-components', '3')
+            self.cmd(f'--repo={self.repository_location}::test', 'extract', '--strip-components', '3')
             assert not os.path.exists('file')
             with self.assert_creates_file('file'):
-                self.cmd('extract', self.repository_location + '::test', '--strip-components', '2')
+                self.cmd(f'--repo={self.repository_location}::test', 'extract', '--strip-components', '2')
             with self.assert_creates_file('dir/file'):
-                self.cmd('extract', self.repository_location + '::test', '--strip-components', '1')
+                self.cmd(f'--repo={self.repository_location}::test', 'extract', '--strip-components', '1')
             with self.assert_creates_file('input/dir/file'):
-                self.cmd('extract', self.repository_location + '::test', '--strip-components', '0')
+                self.cmd(f'--repo={self.repository_location}::test', 'extract', '--strip-components', '0')
 
     def _extract_hardlinks_setup(self):
         os.mkdir(os.path.join(self.input_path, 'dir1'))
@@ -832,8 +832,8 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         os.link(os.path.join(self.input_path, 'dir1/source2'),
                 os.path.join(self.input_path, 'dir1/aaaa'))
 
-        self.cmd('init', '--encryption=repokey', self.repository_location)
-        self.cmd('create', self.repository_location + '::test', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}::test', 'create', 'input')
 
     @requires_hardlinks
     @unittest.skipUnless(llfuse, 'llfuse not installed')
@@ -873,7 +873,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
     def test_extract_hardlinks1(self):
         self._extract_hardlinks_setup()
         with changedir('output'):
-            self.cmd('extract', self.repository_location + '::test')
+            self.cmd(f'--repo={self.repository_location}::test', 'extract')
             assert os.stat('input/source').st_nlink == 4
             assert os.stat('input/abba').st_nlink == 4
             assert os.stat('input/dir1/hardlink').st_nlink == 4
@@ -884,14 +884,14 @@ class ArchiverTestCase(ArchiverTestCaseBase):
     def test_extract_hardlinks2(self):
         self._extract_hardlinks_setup()
         with changedir('output'):
-            self.cmd('extract', self.repository_location + '::test', '--strip-components', '2')
+            self.cmd(f'--repo={self.repository_location}::test', 'extract', '--strip-components', '2')
             assert os.stat('hardlink').st_nlink == 2
             assert os.stat('subdir/hardlink').st_nlink == 2
             assert open('subdir/hardlink', 'rb').read() == b'123456'
             assert os.stat('aaaa').st_nlink == 2
             assert os.stat('source2').st_nlink == 2
         with changedir('output'):
-            self.cmd('extract', self.repository_location + '::test', 'input/dir1')
+            self.cmd(f'--repo={self.repository_location}::test', 'extract', 'input/dir1')
             assert os.stat('input/dir1/hardlink').st_nlink == 2
             assert os.stat('input/dir1/subdir/hardlink').st_nlink == 2
             assert open('input/dir1/subdir/hardlink', 'rb').read() == b'123456'
@@ -909,11 +909,11 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         hl_b = os.path.join(path_b, 'hardlink')
         self.create_regular_file(hl_a, contents=b'123456')
         os.link(hl_a, hl_b)
-        self.cmd('init', '--encryption=none', self.repository_location)
-        self.cmd('create', self.repository_location + '::test', 'input', 'input')  # give input twice!
+        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=none')
+        self.cmd(f'--repo={self.repository_location}::test', 'create', 'input', 'input')  # give input twice!
         # now test extraction
         with changedir('output'):
-            self.cmd('extract', self.repository_location + '::test')
+            self.cmd(f'--repo={self.repository_location}::test', 'extract')
             # if issue #5603 happens, extraction gives rc == 1 (triggering AssertionError) and warnings like:
             # input/a/hardlink: link: [Errno 2] No such file or directory: 'input/a/hardlink' -> 'input/a/hardlink'
             # input/b/hardlink: link: [Errno 2] No such file or directory: 'input/a/hardlink' -> 'input/b/hardlink'
@@ -922,24 +922,24 @@ class ArchiverTestCase(ArchiverTestCaseBase):
             assert os.stat('input/b/hardlink').st_nlink == 2
 
     def test_extract_include_exclude(self):
-        self.cmd('init', '--encryption=repokey', self.repository_location)
+        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
         self.create_regular_file('file1', size=1024 * 80)
         self.create_regular_file('file2', size=1024 * 80)
         self.create_regular_file('file3', size=1024 * 80)
         self.create_regular_file('file4', size=1024 * 80)
-        self.cmd('create', '--exclude=input/file4', self.repository_location + '::test', 'input')
+        self.cmd(f'--repo={self.repository_location}::test', 'create', '--exclude=input/file4', 'input')
         with changedir('output'):
-            self.cmd('extract', self.repository_location + '::test', 'input/file1', )
+            self.cmd(f'--repo={self.repository_location}::test', 'extract', 'input/file1', )
         self.assert_equal(sorted(os.listdir('output/input')), ['file1'])
         with changedir('output'):
-            self.cmd('extract', '--exclude=input/file2', self.repository_location + '::test')
+            self.cmd(f'--repo={self.repository_location}::test', 'extract', '--exclude=input/file2')
         self.assert_equal(sorted(os.listdir('output/input')), ['file1', 'file3'])
         with changedir('output'):
-            self.cmd('extract', '--exclude-from=' + self.exclude_file_path, self.repository_location + '::test')
+            self.cmd(f'--repo={self.repository_location}::test', 'extract', '--exclude-from=' + self.exclude_file_path)
         self.assert_equal(sorted(os.listdir('output/input')), ['file1', 'file3'])
 
     def test_extract_include_exclude_regex(self):
-        self.cmd('init', '--encryption=repokey', self.repository_location)
+        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
         self.create_regular_file('file1', size=1024 * 80)
         self.create_regular_file('file2', size=1024 * 80)
         self.create_regular_file('file3', size=1024 * 80)
@@ -947,32 +947,32 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self.create_regular_file('file333', size=1024 * 80)
 
         # Create with regular expression exclusion for file4
-        self.cmd('create', '--exclude=re:input/file4$', self.repository_location + '::test', 'input')
+        self.cmd(f'--repo={self.repository_location}::test', 'create', '--exclude=re:input/file4$', 'input')
         with changedir('output'):
-            self.cmd('extract', self.repository_location + '::test')
+            self.cmd(f'--repo={self.repository_location}::test', 'extract')
         self.assert_equal(sorted(os.listdir('output/input')), ['file1', 'file2', 'file3', 'file333'])
         shutil.rmtree('output/input')
 
         # Extract with regular expression exclusion
         with changedir('output'):
-            self.cmd('extract', '--exclude=re:file3+', self.repository_location + '::test')
+            self.cmd(f'--repo={self.repository_location}::test', 'extract', '--exclude=re:file3+')
         self.assert_equal(sorted(os.listdir('output/input')), ['file1', 'file2'])
         shutil.rmtree('output/input')
 
         # Combine --exclude with fnmatch and regular expression
         with changedir('output'):
-            self.cmd('extract', '--exclude=input/file2', '--exclude=re:file[01]', self.repository_location + '::test')
+            self.cmd(f'--repo={self.repository_location}::test', 'extract', '--exclude=input/file2', '--exclude=re:file[01]')
         self.assert_equal(sorted(os.listdir('output/input')), ['file3', 'file333'])
         shutil.rmtree('output/input')
 
         # Combine --exclude-from and regular expression exclusion
         with changedir('output'):
-            self.cmd('extract', '--exclude-from=' + self.exclude_file_path, '--exclude=re:file1',
-                     '--exclude=re:file(\\d)\\1\\1$', self.repository_location + '::test')
+            self.cmd(f'--repo={self.repository_location}::test', 'extract', '--exclude-from=' + self.exclude_file_path,
+                     '--exclude=re:file1', '--exclude=re:file(\\d)\\1\\1$')
         self.assert_equal(sorted(os.listdir('output/input')), ['file3'])
 
     def test_extract_include_exclude_regex_from_file(self):
-        self.cmd('init', '--encryption=repokey', self.repository_location)
+        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
         self.create_regular_file('file1', size=1024 * 80)
         self.create_regular_file('file2', size=1024 * 80)
         self.create_regular_file('file3', size=1024 * 80)
@@ -985,9 +985,9 @@ class ArchiverTestCase(ArchiverTestCaseBase):
             fd.write(b're:input/file4$\n')
             fd.write(b'fm:*aa:*thing\n')
 
-        self.cmd('create', '--exclude-from=' + self.exclude_file_path, self.repository_location + '::test', 'input')
+        self.cmd(f'--repo={self.repository_location}::test', 'create', '--exclude-from=' + self.exclude_file_path, 'input')
         with changedir('output'):
-            self.cmd('extract', self.repository_location + '::test')
+            self.cmd(f'--repo={self.repository_location}::test', 'extract')
         self.assert_equal(sorted(os.listdir('output/input')), ['file1', 'file2', 'file3', 'file333'])
         shutil.rmtree('output/input')
 
@@ -996,7 +996,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
             fd.write(b're:file3+\n')
 
         with changedir('output'):
-            self.cmd('extract', '--exclude-from=' + self.exclude_file_path, self.repository_location + '::test')
+            self.cmd(f'--repo={self.repository_location}::test', 'extract', '--exclude-from=' + self.exclude_file_path)
         self.assert_equal(sorted(os.listdir('output/input')), ['file1', 'file2'])
         shutil.rmtree('output/input')
 
@@ -1008,78 +1008,78 @@ class ArchiverTestCase(ArchiverTestCaseBase):
             fd.write(b're:file2$\n')
 
         with changedir('output'):
-            self.cmd('extract', '--exclude-from=' + self.exclude_file_path, self.repository_location + '::test')
+            self.cmd(f'--repo={self.repository_location}::test', 'extract', '--exclude-from=' + self.exclude_file_path)
         self.assert_equal(sorted(os.listdir('output/input')), ['file3'])
 
     def test_extract_with_pattern(self):
-        self.cmd("init", '--encryption=repokey', self.repository_location)
+        self.cmd(f'--repo={self.repository_location}', "init", '--encryption=repokey')
         self.create_regular_file("file1", size=1024 * 80)
         self.create_regular_file("file2", size=1024 * 80)
         self.create_regular_file("file3", size=1024 * 80)
         self.create_regular_file("file4", size=1024 * 80)
         self.create_regular_file("file333", size=1024 * 80)
 
-        self.cmd("create", self.repository_location + "::test", "input")
+        self.cmd(f'--repo={self.repository_location}::test', "create", "input")
 
         # Extract everything with regular expression
         with changedir("output"):
-            self.cmd("extract", self.repository_location + "::test", "re:.*")
+            self.cmd(f'--repo={self.repository_location}::test', "extract", "re:.*")
         self.assert_equal(sorted(os.listdir("output/input")), ["file1", "file2", "file3", "file333", "file4"])
         shutil.rmtree("output/input")
 
         # Extract with pattern while also excluding files
         with changedir("output"):
-            self.cmd("extract", "--exclude=re:file[34]$", self.repository_location + "::test", r"re:file\d$")
+            self.cmd(f'--repo={self.repository_location}::test', "extract", "--exclude=re:file[34]$", r"re:file\d$")
         self.assert_equal(sorted(os.listdir("output/input")), ["file1", "file2"])
         shutil.rmtree("output/input")
 
         # Combine --exclude with pattern for extraction
         with changedir("output"):
-            self.cmd("extract", "--exclude=input/file1", self.repository_location + "::test", "re:file[12]$")
+            self.cmd(f'--repo={self.repository_location}::test', "extract", "--exclude=input/file1", "re:file[12]$")
         self.assert_equal(sorted(os.listdir("output/input")), ["file2"])
         shutil.rmtree("output/input")
 
         # Multiple pattern
         with changedir("output"):
-            self.cmd("extract", self.repository_location + "::test", "fm:input/file1", "fm:*file33*", "input/file2")
+            self.cmd(f'--repo={self.repository_location}::test', "extract", "fm:input/file1", "fm:*file33*", "input/file2")
         self.assert_equal(sorted(os.listdir("output/input")), ["file1", "file2", "file333"])
 
     def test_extract_list_output(self):
-        self.cmd('init', '--encryption=repokey', self.repository_location)
+        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
         self.create_regular_file('file', size=1024 * 80)
 
-        self.cmd('create', self.repository_location + '::test', 'input')
+        self.cmd(f'--repo={self.repository_location}::test', 'create', 'input')
 
         with changedir('output'):
-            output = self.cmd('extract', self.repository_location + '::test')
+            output = self.cmd(f'--repo={self.repository_location}::test', 'extract')
         self.assert_not_in("input/file", output)
         shutil.rmtree('output/input')
 
         with changedir('output'):
-            output = self.cmd('extract', '--info', self.repository_location + '::test')
+            output = self.cmd(f'--repo={self.repository_location}::test', 'extract', '--info')
         self.assert_not_in("input/file", output)
         shutil.rmtree('output/input')
 
         with changedir('output'):
-            output = self.cmd('extract', '--list', self.repository_location + '::test')
+            output = self.cmd(f'--repo={self.repository_location}::test', 'extract', '--list')
         self.assert_in("input/file", output)
         shutil.rmtree('output/input')
 
         with changedir('output'):
-            output = self.cmd('extract', '--list', '--info', self.repository_location + '::test')
+            output = self.cmd(f'--repo={self.repository_location}::test', 'extract', '--list', '--info')
         self.assert_in("input/file", output)
 
     def test_extract_progress(self):
-        self.cmd('init', '--encryption=repokey', self.repository_location)
+        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
         self.create_regular_file('file', size=1024 * 80)
-        self.cmd('create', self.repository_location + '::test', 'input')
+        self.cmd(f'--repo={self.repository_location}::test', 'create', 'input')
 
         with changedir('output'):
-            output = self.cmd('extract', self.repository_location + '::test', '--progress')
+            output = self.cmd(f'--repo={self.repository_location}::test', 'extract', '--progress')
             assert 'Extracting:' in output
 
     def _create_test_caches(self):
-        self.cmd('init', '--encryption=repokey', self.repository_location)
+        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
         self.create_regular_file('file1', size=1024 * 80)
         self.create_regular_file('cache1/%s' % CACHE_TAG_NAME,
                                  contents=CACHE_TAG_CONTENTS + b' extra stuff')
@@ -1093,122 +1093,122 @@ class ArchiverTestCase(ArchiverTestCaseBase):
                                      contents=CACHE_TAG_CONTENTS + b' extra stuff')
 
     def test_create_stdin(self):
-        self.cmd('init', '--encryption=repokey', self.repository_location)
+        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
         input_data = b'\x00foo\n\nbar\n   \n'
-        self.cmd('create', self.repository_location + '::test', '-', input=input_data)
-        item = json.loads(self.cmd('list', '--json-lines', self.repository_location + '::test'))
+        self.cmd(f'--repo={self.repository_location}::test', 'create', '-', input=input_data)
+        item = json.loads(self.cmd(f'--repo={self.repository_location}::test', 'list', '--json-lines'))
         assert item['uid'] == 0
         assert item['gid'] == 0
         assert item['size'] == len(input_data)
         assert item['path'] == 'stdin'
-        extracted_data = self.cmd('extract', '--stdout', self.repository_location + '::test', binary_output=True)
+        extracted_data = self.cmd(f'--repo={self.repository_location}::test', 'extract', '--stdout', binary_output=True)
         assert extracted_data == input_data
 
     def test_create_content_from_command(self):
-        self.cmd('init', '--encryption=repokey', self.repository_location)
+        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
         input_data = 'some test content'
         name = 'a/b/c'
-        self.cmd('create', '--stdin-name', name, '--content-from-command',
-                 self.repository_location + '::test', '--', 'echo', input_data)
-        item = json.loads(self.cmd('list', '--json-lines', self.repository_location + '::test'))
+        self.cmd(f'--repo={self.repository_location}::test', 'create', '--stdin-name', name, '--content-from-command',
+                 '--', 'echo', input_data)
+        item = json.loads(self.cmd(f'--repo={self.repository_location}::test', 'list', '--json-lines'))
         assert item['uid'] == 0
         assert item['gid'] == 0
         assert item['size'] == len(input_data) + 1  # `echo` adds newline
         assert item['path'] == name
-        extracted_data = self.cmd('extract', '--stdout', self.repository_location + '::test')
+        extracted_data = self.cmd(f'--repo={self.repository_location}::test', 'extract', '--stdout')
         assert extracted_data == input_data + '\n'
 
     def test_create_content_from_command_with_failed_command(self):
-        self.cmd('init', '--encryption=repokey', self.repository_location)
-        output = self.cmd('create', '--content-from-command', self.repository_location + '::test',
+        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        output = self.cmd(f'--repo={self.repository_location}::test', 'create', '--content-from-command',
                           '--', 'sh', '-c', 'exit 73;', exit_code=2)
         assert output.endswith("Command 'sh' exited with status 73\n")
-        archive_list = json.loads(self.cmd('list', '--json', self.repository_location))
+        archive_list = json.loads(self.cmd(f'--repo={self.repository_location}', 'list', '--json'))
         assert archive_list['archives'] == []
 
     def test_create_content_from_command_missing_command(self):
-        self.cmd('init', '--encryption=repokey', self.repository_location)
-        output = self.cmd('create', '--content-from-command', self.repository_location + '::test', exit_code=2)
+        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        output = self.cmd(f'--repo={self.repository_location}::test', 'create', '--content-from-command', exit_code=2)
         assert output.endswith('No command given.\n')
 
     def test_create_paths_from_stdin(self):
-        self.cmd('init', '--encryption=repokey', self.repository_location)
+        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
         self.create_regular_file("file1", size=1024 * 80)
         self.create_regular_file("dir1/file2", size=1024 * 80)
         self.create_regular_file("dir1/file3", size=1024 * 80)
         self.create_regular_file("file4", size=1024 * 80)
 
         input_data = b'input/file1\0input/dir1\0input/file4'
-        self.cmd('create', '--paths-from-stdin', '--paths-delimiter', '\\0',
-                 self.repository_location + '::test', input=input_data)
-        archive_list = self.cmd('list', '--json-lines', self.repository_location + '::test')
+        self.cmd(f'--repo={self.repository_location}::test', 'create',
+                 '--paths-from-stdin', '--paths-delimiter', '\\0', input=input_data)
+        archive_list = self.cmd(f'--repo={self.repository_location}::test', 'list', '--json-lines')
         paths = [json.loads(line)['path'] for line in archive_list.split('\n') if line]
         assert paths == ['input/file1', 'input/dir1', 'input/file4']
 
     def test_create_paths_from_command(self):
-        self.cmd('init', '--encryption=repokey', self.repository_location)
+        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
         self.create_regular_file("file1", size=1024 * 80)
         self.create_regular_file("file2", size=1024 * 80)
         self.create_regular_file("file3", size=1024 * 80)
         self.create_regular_file("file4", size=1024 * 80)
 
         input_data = 'input/file1\ninput/file2\ninput/file3'
-        self.cmd('create', '--paths-from-command',
-                 self.repository_location + '::test', '--', 'echo', input_data)
-        archive_list = self.cmd('list', '--json-lines', self.repository_location + '::test')
+        self.cmd(f'--repo={self.repository_location}::test', 'create', '--paths-from-command',
+                 '--', 'echo', input_data)
+        archive_list = self.cmd(f'--repo={self.repository_location}::test', 'list', '--json-lines')
         paths = [json.loads(line)['path'] for line in archive_list.split('\n') if line]
         assert paths == ['input/file1', 'input/file2', 'input/file3']
 
     def test_create_paths_from_command_with_failed_command(self):
-        self.cmd('init', '--encryption=repokey', self.repository_location)
-        output = self.cmd('create', '--paths-from-command', self.repository_location + '::test',
+        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        output = self.cmd(f'--repo={self.repository_location}::test', 'create', '--paths-from-command',
                           '--', 'sh', '-c', 'exit 73;', exit_code=2)
         assert output.endswith("Command 'sh' exited with status 73\n")
-        archive_list = json.loads(self.cmd('list', '--json', self.repository_location))
+        archive_list = json.loads(self.cmd(f'--repo={self.repository_location}', 'list', '--json'))
         assert archive_list['archives'] == []
 
     def test_create_paths_from_command_missing_command(self):
-        self.cmd('init', '--encryption=repokey', self.repository_location)
-        output = self.cmd('create', '--paths-from-command', self.repository_location + '::test', exit_code=2)
+        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        output = self.cmd(f'--repo={self.repository_location}::test', 'create', '--paths-from-command', exit_code=2)
         assert output.endswith('No command given.\n')
 
     def test_create_without_root(self):
         """test create without a root"""
-        self.cmd('init', '--encryption=repokey', self.repository_location)
-        self.cmd('create', self.repository_location + '::test', exit_code=2)
+        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}::test', 'create', exit_code=2)
 
     def test_create_pattern_root(self):
         """test create with only a root pattern"""
-        self.cmd('init', '--encryption=repokey', self.repository_location)
+        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
         self.create_regular_file('file1', size=1024 * 80)
         self.create_regular_file('file2', size=1024 * 80)
-        output = self.cmd('create', '-v', '--list', '--pattern=R input', self.repository_location + '::test')
+        output = self.cmd(f'--repo={self.repository_location}::test', 'create', '-v', '--list', '--pattern=R input')
         self.assert_in("A input/file1", output)
         self.assert_in("A input/file2", output)
 
     def test_create_pattern(self):
         """test file patterns during create"""
-        self.cmd('init', '--encryption=repokey', self.repository_location)
+        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
         self.create_regular_file('file1', size=1024 * 80)
         self.create_regular_file('file2', size=1024 * 80)
         self.create_regular_file('file_important', size=1024 * 80)
-        output = self.cmd('create', '-v', '--list',
+        output = self.cmd(f'--repo={self.repository_location}::test', 'create', '-v', '--list',
                           '--pattern=+input/file_important', '--pattern=-input/file*',
-                          self.repository_location + '::test', 'input')
+                          'input')
         self.assert_in("A input/file_important", output)
         self.assert_in('x input/file1', output)
         self.assert_in('x input/file2', output)
 
     def test_create_pattern_file(self):
         """test file patterns during create"""
-        self.cmd('init', '--encryption=repokey', self.repository_location)
+        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
         self.create_regular_file('file1', size=1024 * 80)
         self.create_regular_file('file2', size=1024 * 80)
         self.create_regular_file('otherfile', size=1024 * 80)
         self.create_regular_file('file_important', size=1024 * 80)
-        output = self.cmd('create', '-v', '--list',
+        output = self.cmd(f'--repo={self.repository_location}::test', 'create', '-v', '--list',
                           '--pattern=-input/otherfile', '--patterns-from=' + self.patterns_file_path,
-                          self.repository_location + '::test', 'input')
+                          'input')
         self.assert_in("A input/file_important", output)
         self.assert_in('x input/file1', output)
         self.assert_in('x input/file2', output)
@@ -1220,13 +1220,13 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         with open(self.patterns_file_path2, 'wb') as fd:
             fd.write(b'+ input/x/b\n- input/x*\n')
 
-        self.cmd('init', '--encryption=repokey', self.repository_location)
+        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
         self.create_regular_file('x/a/foo_a', size=1024 * 80)
         self.create_regular_file('x/b/foo_b', size=1024 * 80)
         self.create_regular_file('y/foo_y', size=1024 * 80)
-        output = self.cmd('create', '-v', '--list',
+        output = self.cmd(f'--repo={self.repository_location}::test', 'create', '-v', '--list',
                           '--patterns-from=' + self.patterns_file_path2,
-                          self.repository_location + '::test', 'input')
+                          'input')
         self.assert_in('x input/x/a/foo_a', output)
         self.assert_in("A input/x/b/foo_b", output)
         self.assert_in('A input/y/foo_y', output)
@@ -1237,13 +1237,13 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         with open(self.patterns_file_path2, 'wb') as fd:
             fd.write(b'+ input/x/b\n! input/x*\n')
 
-        self.cmd('init', '--encryption=repokey', self.repository_location)
+        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
         self.create_regular_file('x/a/foo_a', size=1024 * 80)
         self.create_regular_file('x/b/foo_b', size=1024 * 80)
         self.create_regular_file('y/foo_y', size=1024 * 80)
-        output = self.cmd('create', '-v', '--list',
+        output = self.cmd(f'--repo={self.repository_location}::test', 'create', '-v', '--list',
                           '--patterns-from=' + self.patterns_file_path2,
-                          self.repository_location + '::test', 'input')
+                          'input')
         self.assert_not_in('input/x/a/foo_a', output)
         self.assert_not_in('input/x/a', output)
         self.assert_in('A input/y/foo_y', output)
@@ -1254,17 +1254,17 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         with open(self.patterns_file_path2, 'wb') as fd:
             fd.write(b'+ input/x/a\n+ input/x/b\n- input/x*\n')
 
-        self.cmd('init', '--encryption=repokey', self.repository_location)
+        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
 
         self.create_regular_file('x/a/foo_a', size=1024 * 80)
         self.create_regular_file('x/b/foo_b', size=1024 * 80)
         with changedir('input'):
-            self.cmd('create', '--patterns-from=' + self.patterns_file_path2,
-                     self.repository_location + '::test', '.')
+            self.cmd(f'--repo={self.repository_location}::test', 'create', '--patterns-from=' + self.patterns_file_path2,
+                     '.')
 
         # list the archive and verify that the "intermediate" folders appear before
         # their contents
-        out = self.cmd('list', '--format', '{type} {path}{NL}', self.repository_location + '::test')
+        out = self.cmd(f'--repo={self.repository_location}::test', 'list', '--format', '{type} {path}{NL}')
         out_list = out.splitlines()
 
         self.assert_in('d x/a', out_list)
@@ -1275,50 +1275,49 @@ class ArchiverTestCase(ArchiverTestCaseBase):
 
     def test_create_no_cache_sync(self):
         self.create_test_files()
-        self.cmd('init', '--encryption=repokey', self.repository_location)
-        self.cmd('delete', '--cache-only', self.repository_location)
-        create_json = json.loads(self.cmd('create', '--no-cache-sync', self.repository_location + '::test', 'input',
+        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'delete', '--cache-only')
+        create_json = json.loads(self.cmd(f'--repo={self.repository_location}::test', 'create', '--no-cache-sync', 'input',
                                           '--json', '--error'))  # ignore experimental warning
-        info_json = json.loads(self.cmd('info', self.repository_location + '::test', '--json'))
+        info_json = json.loads(self.cmd(f'--repo={self.repository_location}::test', 'info', '--json'))
         create_stats = create_json['cache']['stats']
         info_stats = info_json['cache']['stats']
         assert create_stats == info_stats
-        self.cmd('delete', '--cache-only', self.repository_location)
-        self.cmd('create', '--no-cache-sync', self.repository_location + '::test2', 'input')
-        self.cmd('info', self.repository_location)
-        self.cmd('check', self.repository_location)
+        self.cmd(f'--repo={self.repository_location}', 'delete', '--cache-only')
+        self.cmd(f'--repo={self.repository_location}::test2', 'create', '--no-cache-sync', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'info')
+        self.cmd(f'--repo={self.repository_location}', 'check')
 
     def test_extract_pattern_opt(self):
-        self.cmd('init', '--encryption=repokey', self.repository_location)
+        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
         self.create_regular_file('file1', size=1024 * 80)
         self.create_regular_file('file2', size=1024 * 80)
         self.create_regular_file('file_important', size=1024 * 80)
-        self.cmd('create', self.repository_location + '::test', 'input')
+        self.cmd(f'--repo={self.repository_location}::test', 'create', 'input')
         with changedir('output'):
-            self.cmd('extract',
-                     '--pattern=+input/file_important', '--pattern=-input/file*',
-                     self.repository_location + '::test')
+            self.cmd(f'--repo={self.repository_location}::test', 'extract',
+                     '--pattern=+input/file_important', '--pattern=-input/file*')
         self.assert_equal(sorted(os.listdir('output/input')), ['file_important'])
 
     def _assert_test_caches(self):
         with changedir('output'):
-            self.cmd('extract', self.repository_location + '::test')
+            self.cmd(f'--repo={self.repository_location}::test', 'extract')
         self.assert_equal(sorted(os.listdir('output/input')), ['cache2', 'file1'])
         self.assert_equal(sorted(os.listdir('output/input/cache2')), [CACHE_TAG_NAME])
 
     def test_exclude_caches(self):
         self._create_test_caches()
-        self.cmd('create', '--exclude-caches', self.repository_location + '::test', 'input')
+        self.cmd(f'--repo={self.repository_location}::test', 'create', '--exclude-caches', 'input')
         self._assert_test_caches()
 
     def test_recreate_exclude_caches(self):
         self._create_test_caches()
-        self.cmd('create', self.repository_location + '::test', 'input')
-        self.cmd('recreate', '--exclude-caches', self.repository_location + '::test')
+        self.cmd(f'--repo={self.repository_location}::test', 'create', 'input')
+        self.cmd(f'--repo={self.repository_location}::test', 'recreate', '--exclude-caches')
         self._assert_test_caches()
 
     def _create_test_tagged(self):
-        self.cmd('init', '--encryption=repokey', self.repository_location)
+        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
         self.create_regular_file('file1', size=1024 * 80)
         self.create_regular_file('tagged1/.NOBACKUP')
         self.create_regular_file('tagged2/00-NOBACKUP')
@@ -1326,23 +1325,24 @@ class ArchiverTestCase(ArchiverTestCaseBase):
 
     def _assert_test_tagged(self):
         with changedir('output'):
-            self.cmd('extract', self.repository_location + '::test')
+            self.cmd(f'--repo={self.repository_location}::test', 'extract')
         self.assert_equal(sorted(os.listdir('output/input')), ['file1'])
 
     def test_exclude_tagged(self):
         self._create_test_tagged()
-        self.cmd('create', '--exclude-if-present', '.NOBACKUP', '--exclude-if-present', '00-NOBACKUP', self.repository_location + '::test', 'input')
+        self.cmd(f'--repo={self.repository_location}::test', 'create', '--exclude-if-present', '.NOBACKUP',
+                 '--exclude-if-present', '00-NOBACKUP', 'input')
         self._assert_test_tagged()
 
     def test_recreate_exclude_tagged(self):
         self._create_test_tagged()
-        self.cmd('create', self.repository_location + '::test', 'input')
-        self.cmd('recreate', '--exclude-if-present', '.NOBACKUP', '--exclude-if-present', '00-NOBACKUP',
-                 self.repository_location + '::test')
+        self.cmd(f'--repo={self.repository_location}::test', 'create', 'input')
+        self.cmd(f'--repo={self.repository_location}::test', 'recreate', '--exclude-if-present', '.NOBACKUP',
+                 '--exclude-if-present', '00-NOBACKUP')
         self._assert_test_tagged()
 
     def _create_test_keep_tagged(self):
-        self.cmd('init', '--encryption=repokey', self.repository_location)
+        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
         self.create_regular_file('file0', size=1024)
         self.create_regular_file('tagged1/.NOBACKUP1')
         self.create_regular_file('tagged1/file1', size=1024)
@@ -1359,7 +1359,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
 
     def _assert_test_keep_tagged(self):
         with changedir('output'):
-            self.cmd('extract', self.repository_location + '::test')
+            self.cmd(f'--repo={self.repository_location}::test', 'extract')
         self.assert_equal(sorted(os.listdir('output/input')), ['file0', 'tagged1', 'tagged2', 'tagged3', 'taggedall'])
         self.assert_equal(os.listdir('output/input/tagged1'), ['.NOBACKUP1'])
         self.assert_equal(os.listdir('output/input/tagged2'), ['.NOBACKUP2'])
@@ -1369,29 +1369,29 @@ class ArchiverTestCase(ArchiverTestCaseBase):
 
     def test_exclude_keep_tagged(self):
         self._create_test_keep_tagged()
-        self.cmd('create', '--exclude-if-present', '.NOBACKUP1', '--exclude-if-present', '.NOBACKUP2',
-                 '--exclude-caches', '--keep-exclude-tags', self.repository_location + '::test', 'input')
+        self.cmd(f'--repo={self.repository_location}::test', 'create', '--exclude-if-present', '.NOBACKUP1',
+                 '--exclude-if-present', '.NOBACKUP2', '--exclude-caches', '--keep-exclude-tags', 'input')
         self._assert_test_keep_tagged()
 
     def test_recreate_exclude_keep_tagged(self):
         self._create_test_keep_tagged()
-        self.cmd('create', self.repository_location + '::test', 'input')
-        self.cmd('recreate', '--exclude-if-present', '.NOBACKUP1', '--exclude-if-present', '.NOBACKUP2',
-                 '--exclude-caches', '--keep-exclude-tags', self.repository_location + '::test')
+        self.cmd(f'--repo={self.repository_location}::test', 'create', 'input')
+        self.cmd(f'--repo={self.repository_location}::test', 'recreate', '--exclude-if-present', '.NOBACKUP1',
+                 '--exclude-if-present', '.NOBACKUP2', '--exclude-caches', '--keep-exclude-tags')
         self._assert_test_keep_tagged()
 
     @pytest.mark.skipif(not are_hardlinks_supported(), reason='hardlinks not supported')
     def test_recreate_hardlinked_tags(self):  # test for issue #4911
-        self.cmd('init', '--encryption=none', self.repository_location)
+        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=none')
         self.create_regular_file('file1', contents=CACHE_TAG_CONTENTS)  # "wrong" filename, but correct tag contents
         os.mkdir(os.path.join(self.input_path, 'subdir'))  # to make sure the tag is encountered *after* file1
         os.link(os.path.join(self.input_path, 'file1'),
                 os.path.join(self.input_path, 'subdir', CACHE_TAG_NAME))  # correct tag name, hardlink to file1
-        self.cmd('create', self.repository_location + '::test', 'input')
+        self.cmd(f'--repo={self.repository_location}::test', 'create', 'input')
         # in the "test" archive, we now have, in this order:
         # - a regular file item for "file1"
         # - a hardlink item for "CACHEDIR.TAG" referring back to file1 for its contents
-        self.cmd('recreate', '--exclude-caches', '--keep-exclude-tags', self.repository_location + '::test')
+        self.cmd(f'--repo={self.repository_location}::test', 'recreate', '--exclude-caches', '--keep-exclude-tags')
         # if issue #4911 is present, the recreate will crash with a KeyError for "input/file1"
 
     @pytest.mark.skipif(not xattr.XATTR_FAKEROOT, reason='Linux capabilities test, requires fakeroot >= 1.20.2')
@@ -1408,11 +1408,11 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         capabilities = b'\x01\x00\x00\x02\x00 \x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
         self.create_regular_file('file')
         xattr.setxattr(b'input/file', b'security.capability', capabilities)
-        self.cmd('init', '--encryption=repokey', self.repository_location)
-        self.cmd('create', self.repository_location + '::test', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}::test', 'create', 'input')
         with changedir('output'):
             with patch.object(os, 'fchown', patched_fchown):
-                self.cmd('extract', self.repository_location + '::test')
+                self.cmd(f'--repo={self.repository_location}::test', 'extract')
             assert xattr.getxattr(b'input/file', b'security.capability') == capabilities
 
     @pytest.mark.skipif(not xattr.XATTR_FAKEROOT, reason='xattr not supported on this system or on this version of'
@@ -1429,88 +1429,88 @@ class ArchiverTestCase(ArchiverTestCaseBase):
 
         self.create_regular_file('file')
         xattr.setxattr(b'input/file', b'user.attribute', b'value')
-        self.cmd('init', self.repository_location, '-e' 'none')
-        self.cmd('create', self.repository_location + '::test', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'init', '-e' 'none')
+        self.cmd(f'--repo={self.repository_location}::test', 'create', 'input')
         with changedir('output'):
             input_abspath = os.path.abspath('input/file')
             with patch.object(xattr, 'setxattr', patched_setxattr_E2BIG):
-                out = self.cmd('extract', self.repository_location + '::test', exit_code=EXIT_WARNING)
+                out = self.cmd(f'--repo={self.repository_location}::test', 'extract', exit_code=EXIT_WARNING)
                 assert ': when setting extended attribute user.attribute: too big for this filesystem\n' in out
             os.remove(input_abspath)
             with patch.object(xattr, 'setxattr', patched_setxattr_ENOTSUP):
-                out = self.cmd('extract', self.repository_location + '::test', exit_code=EXIT_WARNING)
+                out = self.cmd(f'--repo={self.repository_location}::test', 'extract', exit_code=EXIT_WARNING)
                 assert ': when setting extended attribute user.attribute: xattrs not supported on this filesystem\n' in out
             os.remove(input_abspath)
             with patch.object(xattr, 'setxattr', patched_setxattr_EACCES):
-                out = self.cmd('extract', self.repository_location + '::test', exit_code=EXIT_WARNING)
+                out = self.cmd(f'--repo={self.repository_location}::test', 'extract', exit_code=EXIT_WARNING)
                 assert ': when setting extended attribute user.attribute: Permission denied\n' in out
             assert os.path.isfile(input_abspath)
 
     def test_path_normalization(self):
-        self.cmd('init', '--encryption=repokey', self.repository_location)
+        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
         self.create_regular_file('dir1/dir2/file', size=1024 * 80)
         with changedir('input/dir1/dir2'):
-            self.cmd('create', self.repository_location + '::test', '../../../input/dir1/../dir1/dir2/..')
-        output = self.cmd('list', self.repository_location + '::test')
+            self.cmd(f'--repo={self.repository_location}::test', 'create', '../../../input/dir1/../dir1/dir2/..')
+        output = self.cmd(f'--repo={self.repository_location}::test', 'list')
         self.assert_not_in('..', output)
         self.assert_in(' input/dir1/dir2/file', output)
 
     def test_exclude_normalization(self):
-        self.cmd('init', '--encryption=repokey', self.repository_location)
+        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
         self.create_regular_file('file1', size=1024 * 80)
         self.create_regular_file('file2', size=1024 * 80)
         with changedir('input'):
-            self.cmd('create', '--exclude=file1', self.repository_location + '::test1', '.')
+            self.cmd(f'--repo={self.repository_location}::test1', 'create', '--exclude=file1', '.')
         with changedir('output'):
-            self.cmd('extract', self.repository_location + '::test1')
+            self.cmd(f'--repo={self.repository_location}::test1', 'extract')
         self.assert_equal(sorted(os.listdir('output')), ['file2'])
         with changedir('input'):
-            self.cmd('create', '--exclude=./file1', self.repository_location + '::test2', '.')
+            self.cmd(f'--repo={self.repository_location}::test2', 'create', '--exclude=./file1', '.')
         with changedir('output'):
-            self.cmd('extract', self.repository_location + '::test2')
+            self.cmd(f'--repo={self.repository_location}::test2', 'extract')
         self.assert_equal(sorted(os.listdir('output')), ['file2'])
-        self.cmd('create', '--exclude=input/./file1', self.repository_location + '::test3', 'input')
+        self.cmd(f'--repo={self.repository_location}::test3', 'create', '--exclude=input/./file1', 'input')
         with changedir('output'):
-            self.cmd('extract', self.repository_location + '::test3')
+            self.cmd(f'--repo={self.repository_location}::test3', 'extract')
         self.assert_equal(sorted(os.listdir('output/input')), ['file2'])
 
     def test_repeated_files(self):
         self.create_regular_file('file1', size=1024 * 80)
-        self.cmd('init', '--encryption=repokey', self.repository_location)
-        self.cmd('create', self.repository_location + '::test', 'input', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}::test', 'create', 'input', 'input')
 
     def test_overwrite(self):
         self.create_regular_file('file1', size=1024 * 80)
         self.create_regular_file('dir2/file2', size=1024 * 80)
-        self.cmd('init', '--encryption=repokey', self.repository_location)
-        self.cmd('create', self.repository_location + '::test', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}::test', 'create', 'input')
         # Overwriting regular files and directories should be supported
         os.mkdir('output/input')
         os.mkdir('output/input/file1')
         os.mkdir('output/input/dir2')
         with changedir('output'):
-            self.cmd('extract', self.repository_location + '::test')
+            self.cmd(f'--repo={self.repository_location}::test', 'extract')
         self.assert_dirs_equal('input', 'output/input')
         # But non-empty dirs should fail
         os.unlink('output/input/file1')
         os.mkdir('output/input/file1')
         os.mkdir('output/input/file1/dir')
         with changedir('output'):
-            self.cmd('extract', self.repository_location + '::test', exit_code=1)
+            self.cmd(f'--repo={self.repository_location}::test', 'extract', exit_code=1)
 
     def test_rename(self):
         self.create_regular_file('file1', size=1024 * 80)
         self.create_regular_file('dir2/file2', size=1024 * 80)
-        self.cmd('init', '--encryption=repokey', self.repository_location)
-        self.cmd('create', self.repository_location + '::test', 'input')
-        self.cmd('create', self.repository_location + '::test.2', 'input')
-        self.cmd('extract', '--dry-run', self.repository_location + '::test')
-        self.cmd('extract', '--dry-run', self.repository_location + '::test.2')
-        self.cmd('rename', self.repository_location + '::test', 'test.3')
-        self.cmd('extract', '--dry-run', self.repository_location + '::test.2')
-        self.cmd('rename', self.repository_location + '::test.2', 'test.4')
-        self.cmd('extract', '--dry-run', self.repository_location + '::test.3')
-        self.cmd('extract', '--dry-run', self.repository_location + '::test.4')
+        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}::test', 'create', 'input')
+        self.cmd(f'--repo={self.repository_location}::test.2', 'create', 'input')
+        self.cmd(f'--repo={self.repository_location}::test', 'extract', '--dry-run')
+        self.cmd(f'--repo={self.repository_location}::test.2', 'extract', '--dry-run')
+        self.cmd(f'--repo={self.repository_location}::test', 'rename', 'TODO_test', 'test.3')
+        self.cmd(f'--repo={self.repository_location}::test.2', 'extract', '--dry-run')
+        self.cmd(f'--repo={self.repository_location}::test.2', 'rename', 'TODO_test.2', 'test.4')
+        self.cmd(f'--repo={self.repository_location}::test.3', 'extract', '--dry-run')
+        self.cmd(f'--repo={self.repository_location}::test.4', 'extract', '--dry-run')
         # Make sure both archives have been renamed
         with Repository(self.repository_path) as repository:
             manifest, key = Manifest.load(repository, Manifest.NO_OPERATION_CHECK)
@@ -1520,20 +1520,20 @@ class ArchiverTestCase(ArchiverTestCaseBase):
 
     def test_info(self):
         self.create_regular_file('file1', size=1024 * 80)
-        self.cmd('init', '--encryption=repokey', self.repository_location)
-        self.cmd('create', self.repository_location + '::test', 'input')
-        info_repo = self.cmd('info', self.repository_location)
+        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}::test', 'create', 'input')
+        info_repo = self.cmd(f'--repo={self.repository_location}', 'info')
         assert 'All archives:' in info_repo
-        info_archive = self.cmd('info', self.repository_location + '::test')
+        info_archive = self.cmd(f'--repo={self.repository_location}::test', 'info')
         assert 'Archive name: test\n' in info_archive
-        info_archive = self.cmd('info', '--first', '1', self.repository_location)
+        info_archive = self.cmd(f'--repo={self.repository_location}', 'info', '--first', '1')
         assert 'Archive name: test\n' in info_archive
 
     def test_info_json(self):
         self.create_regular_file('file1', size=1024 * 80)
-        self.cmd('init', '--encryption=repokey', self.repository_location)
-        self.cmd('create', self.repository_location + '::test', 'input')
-        info_repo = json.loads(self.cmd('info', '--json', self.repository_location))
+        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}::test', 'create', 'input')
+        info_repo = json.loads(self.cmd(f'--repo={self.repository_location}', 'info', '--json'))
         repository = info_repo['repository']
         assert len(repository['id']) == 64
         assert 'last_modified' in repository
@@ -1545,7 +1545,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         assert all(isinstance(o, int) for o in stats.values())
         assert all(key in stats for key in ('total_chunks', 'total_size', 'total_unique_chunks', 'unique_size'))
 
-        info_archive = json.loads(self.cmd('info', '--json', self.repository_location + '::test'))
+        info_archive = json.loads(self.cmd(f'--repo={self.repository_location}::test', 'info', '--json'))
         assert info_repo['repository'] == info_archive['repository']
         assert info_repo['cache'] == info_archive['cache']
         archives = info_archive['archives']
@@ -1561,47 +1561,47 @@ class ArchiverTestCase(ArchiverTestCaseBase):
 
     def test_info_json_of_empty_archive(self):
         """See https://github.com/borgbackup/borg/issues/6120"""
-        self.cmd('init', '--encryption=repokey', self.repository_location)
-        info_repo = json.loads(self.cmd('info', '--json', '--first=1', self.repository_location))
+        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        info_repo = json.loads(self.cmd(f'--repo={self.repository_location}', 'info', '--json', '--first=1'))
         assert info_repo["archives"] == []
-        info_repo = json.loads(self.cmd('info', '--json', '--last=1', self.repository_location))
+        info_repo = json.loads(self.cmd(f'--repo={self.repository_location}', 'info', '--json', '--last=1'))
         assert info_repo["archives"] == []
 
     def test_comment(self):
         self.create_regular_file('file1', size=1024 * 80)
-        self.cmd('init', '--encryption=repokey', self.repository_location)
-        self.cmd('create', self.repository_location + '::test1', 'input')
-        self.cmd('create', '--comment', 'this is the comment', self.repository_location + '::test2', 'input')
-        self.cmd('create', '--comment', '"deleted" comment', self.repository_location + '::test3', 'input')
-        self.cmd('create', '--comment', 'preserved comment', self.repository_location + '::test4', 'input')
-        assert 'Comment: \n' in self.cmd('info', self.repository_location + '::test1')
-        assert 'Comment: this is the comment' in self.cmd('info', self.repository_location + '::test2')
+        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}::test1', 'create', 'input')
+        self.cmd(f'--repo={self.repository_location}::test2', 'create', '--comment', 'this is the comment', 'input')
+        self.cmd(f'--repo={self.repository_location}::test3', 'create', '--comment', '"deleted" comment', 'input')
+        self.cmd(f'--repo={self.repository_location}::test4', 'create', '--comment', 'preserved comment', 'input')
+        assert 'Comment: \n' in self.cmd(f'--repo={self.repository_location}::test1', 'info')
+        assert 'Comment: this is the comment' in self.cmd(f'--repo={self.repository_location}::test2', 'info')
 
-        self.cmd('recreate', self.repository_location + '::test1', '--comment', 'added comment')
-        self.cmd('recreate', self.repository_location + '::test2', '--comment', 'modified comment')
-        self.cmd('recreate', self.repository_location + '::test3', '--comment', '')
-        self.cmd('recreate', self.repository_location + '::test4', '12345')
-        assert 'Comment: added comment' in self.cmd('info', self.repository_location + '::test1')
-        assert 'Comment: modified comment' in self.cmd('info', self.repository_location + '::test2')
-        assert 'Comment: \n' in self.cmd('info', self.repository_location + '::test3')
-        assert 'Comment: preserved comment' in self.cmd('info', self.repository_location + '::test4')
+        self.cmd(f'--repo={self.repository_location}::test1', 'recreate', '--comment', 'added comment')
+        self.cmd(f'--repo={self.repository_location}::test2', 'recreate', '--comment', 'modified comment')
+        self.cmd(f'--repo={self.repository_location}::test3', 'recreate', '--comment', '')
+        self.cmd(f'--repo={self.repository_location}::test4', 'recreate', '12345')
+        assert 'Comment: added comment' in self.cmd(f'--repo={self.repository_location}::test1', 'info')
+        assert 'Comment: modified comment' in self.cmd(f'--repo={self.repository_location}::test2', 'info')
+        assert 'Comment: \n' in self.cmd(f'--repo={self.repository_location}::test3', 'info')
+        assert 'Comment: preserved comment' in self.cmd(f'--repo={self.repository_location}::test4', 'info')
 
     def test_delete(self):
         self.create_regular_file('file1', size=1024 * 80)
         self.create_regular_file('dir2/file2', size=1024 * 80)
-        self.cmd('init', '--encryption=repokey', self.repository_location)
-        self.cmd('create', self.repository_location + '::test', 'input')
-        self.cmd('create', self.repository_location + '::test.2', 'input')
-        self.cmd('create', self.repository_location + '::test.3', 'input')
-        self.cmd('create', self.repository_location + '::another_test.1', 'input')
-        self.cmd('create', self.repository_location + '::another_test.2', 'input')
-        self.cmd('extract', '--dry-run', self.repository_location + '::test')
-        self.cmd('extract', '--dry-run', self.repository_location + '::test.2')
-        self.cmd('delete', '--prefix', 'another_', self.repository_location)
-        self.cmd('delete', '--last', '1', self.repository_location)
-        self.cmd('delete', self.repository_location + '::test')
-        self.cmd('extract', '--dry-run', self.repository_location + '::test.2')
-        output = self.cmd('delete', '--stats', self.repository_location + '::test.2')
+        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}::test', 'create', 'input')
+        self.cmd(f'--repo={self.repository_location}::test.2', 'create', 'input')
+        self.cmd(f'--repo={self.repository_location}::test.3', 'create', 'input')
+        self.cmd(f'--repo={self.repository_location}::another_test.1', 'create', 'input')
+        self.cmd(f'--repo={self.repository_location}::another_test.2', 'create', 'input')
+        self.cmd(f'--repo={self.repository_location}::test', 'extract', '--dry-run')
+        self.cmd(f'--repo={self.repository_location}::test.2', 'extract', '--dry-run')
+        self.cmd(f'--repo={self.repository_location}', 'delete', '--prefix', 'another_')
+        self.cmd(f'--repo={self.repository_location}', 'delete', '--last', '1')
+        self.cmd(f'--repo={self.repository_location}::test', 'delete')
+        self.cmd(f'--repo={self.repository_location}::test.2', 'extract', '--dry-run')
+        output = self.cmd(f'--repo={self.repository_location}::test.2', 'delete', '--stats')
         self.assert_in('Deleted data:', output)
         # Make sure all data except the manifest has been deleted
         with Repository(self.repository_path) as repository:
@@ -1609,31 +1609,31 @@ class ArchiverTestCase(ArchiverTestCaseBase):
 
     def test_delete_multiple(self):
         self.create_regular_file('file1', size=1024 * 80)
-        self.cmd('init', '--encryption=repokey', self.repository_location)
-        self.cmd('create', self.repository_location + '::test1', 'input')
-        self.cmd('create', self.repository_location + '::test2', 'input')
-        self.cmd('create', self.repository_location + '::test3', 'input')
-        self.cmd('delete', self.repository_location + '::test1', 'test2')
-        self.cmd('extract', '--dry-run', self.repository_location + '::test3')
-        self.cmd('delete', self.repository_location, 'test3')
-        assert not self.cmd('list', self.repository_location)
+        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}::test1', 'create', 'input')
+        self.cmd(f'--repo={self.repository_location}::test2', 'create', 'input')
+        self.cmd(f'--repo={self.repository_location}::test3', 'create', 'input')
+        self.cmd(f'--repo={self.repository_location}::test1', 'delete', 'test2')
+        self.cmd(f'--repo={self.repository_location}::test3', 'extract', '--dry-run')
+        self.cmd(f'--repo={self.repository_location}::test3', 'delete')
+        assert not self.cmd(f'--repo={self.repository_location}', 'list')
 
     def test_delete_repo(self):
         self.create_regular_file('file1', size=1024 * 80)
         self.create_regular_file('dir2/file2', size=1024 * 80)
-        self.cmd('init', '--encryption=repokey', self.repository_location)
-        self.cmd('create', self.repository_location + '::test', 'input')
-        self.cmd('create', self.repository_location + '::test.2', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}::test', 'create', 'input')
+        self.cmd(f'--repo={self.repository_location}::test.2', 'create', 'input')
         os.environ['BORG_DELETE_I_KNOW_WHAT_I_AM_DOING'] = 'no'
-        self.cmd('delete', self.repository_location, exit_code=2)
+        self.cmd(f'--repo={self.repository_location}', 'delete', exit_code=2)
         assert os.path.exists(self.repository_path)
         os.environ['BORG_DELETE_I_KNOW_WHAT_I_AM_DOING'] = 'YES'
-        self.cmd('delete', self.repository_location)
+        self.cmd(f'--repo={self.repository_location}', 'delete')
         # Make sure the repo is gone
         self.assertFalse(os.path.exists(self.repository_path))
 
     def test_delete_force(self):
-        self.cmd('init', '--encryption=none', self.repository_location)
+        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=none')
         self.create_src_archive('test')
         with Repository(self.repository_path, exclusive=True) as repository:
             manifest, key = Manifest.load(repository, Manifest.NO_OPERATION_CHECK)
@@ -1645,14 +1645,14 @@ class ArchiverTestCase(ArchiverTestCaseBase):
             else:
                 assert False  # missed the file
             repository.commit(compact=False)
-        output = self.cmd('delete', '--force', self.repository_location + '::test')
+        output = self.cmd(f'--repo={self.repository_location}::test', 'delete', '--force')
         self.assert_in('deleted archive was corrupted', output)
-        self.cmd('check', '--repair', self.repository_location)
-        output = self.cmd('list', self.repository_location)
+        self.cmd(f'--repo={self.repository_location}', 'check', '--repair')
+        output = self.cmd(f'--repo={self.repository_location}', 'list')
         self.assert_not_in('test', output)
 
     def test_delete_double_force(self):
-        self.cmd('init', '--encryption=none', self.repository_location)
+        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=none')
         self.create_src_archive('test')
         with Repository(self.repository_path, exclusive=True) as repository:
             manifest, key = Manifest.load(repository, Manifest.NO_OPERATION_CHECK)
@@ -1660,16 +1660,16 @@ class ArchiverTestCase(ArchiverTestCaseBase):
             id = archive.metadata.items[0]
             repository.put(id, b'corrupted items metadata stream chunk')
             repository.commit(compact=False)
-        self.cmd('delete', '--force', '--force', self.repository_location + '::test')
-        self.cmd('check', '--repair', self.repository_location)
-        output = self.cmd('list', self.repository_location)
+        self.cmd(f'--repo={self.repository_location}::test', 'delete', '--force', '--force')
+        self.cmd(f'--repo={self.repository_location}', 'check', '--repair')
+        output = self.cmd(f'--repo={self.repository_location}', 'list')
         self.assert_not_in('test', output)
 
     def test_corrupted_repository(self):
-        self.cmd('init', '--encryption=repokey', self.repository_location)
+        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
         self.create_src_archive('test')
-        self.cmd('extract', '--dry-run', self.repository_location + '::test')
-        output = self.cmd('check', '--show-version', self.repository_location)
+        self.cmd(f'--repo={self.repository_location}::test', 'extract', '--dry-run')
+        output = self.cmd(f'--repo={self.repository_location}', 'check', '--show-version')
         self.assert_in('borgbackup version', output)  # implied output even without --info given
         self.assert_not_in('Starting repository check', output)  # --info not given for root logger
 
@@ -1677,103 +1677,103 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         with open(os.path.join(self.tmpdir, 'repository', 'data', '0', name), 'r+b') as fd:
             fd.seek(100)
             fd.write(b'XXXX')
-        output = self.cmd('check', '--info', self.repository_location, exit_code=1)
+        output = self.cmd(f'--repo={self.repository_location}', 'check', '--info', exit_code=1)
         self.assert_in('Starting repository check', output)  # --info given for root logger
 
     def test_readonly_check(self):
-        self.cmd('init', '--encryption=repokey', self.repository_location)
+        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
         self.create_src_archive('test')
         with self.read_only(self.repository_path):
             # verify that command normally doesn't work with read-only repo
             if self.FORK_DEFAULT:
-                self.cmd('check', '--verify-data', self.repository_location, exit_code=EXIT_ERROR)
+                self.cmd(f'--repo={self.repository_location}', 'check', '--verify-data', exit_code=EXIT_ERROR)
             else:
                 with pytest.raises((LockFailed, RemoteRepository.RPCError)) as excinfo:
-                    self.cmd('check', '--verify-data', self.repository_location)
+                    self.cmd(f'--repo={self.repository_location}', 'check', '--verify-data')
                 if isinstance(excinfo.value, RemoteRepository.RPCError):
                     assert excinfo.value.exception_class == 'LockFailed'
             # verify that command works with read-only repo when using --bypass-lock
-            self.cmd('check', '--verify-data', self.repository_location, '--bypass-lock')
+            self.cmd(f'--repo={self.repository_location}', 'check', '--verify-data', '--bypass-lock')
 
     def test_readonly_diff(self):
-        self.cmd('init', '--encryption=repokey', self.repository_location)
+        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
         self.create_src_archive('a')
         self.create_src_archive('b')
         with self.read_only(self.repository_path):
             # verify that command normally doesn't work with read-only repo
             if self.FORK_DEFAULT:
-                self.cmd('diff', '%s::a' % self.repository_location, 'b', exit_code=EXIT_ERROR)
+                self.cmd(f'--repo={self.repository_location}::a', 'diff', 'TODO_a', 'b', exit_code=EXIT_ERROR)
             else:
                 with pytest.raises((LockFailed, RemoteRepository.RPCError)) as excinfo:
-                    self.cmd('diff', '%s::a' % self.repository_location, 'b')
+                    self.cmd(f'--repo={self.repository_location}::a', 'diff', 'TODO_a', 'b')
                 if isinstance(excinfo.value, RemoteRepository.RPCError):
                     assert excinfo.value.exception_class == 'LockFailed'
             # verify that command works with read-only repo when using --bypass-lock
-            self.cmd('diff', '%s::a' % self.repository_location, 'b', '--bypass-lock')
+            self.cmd(f'--repo={self.repository_location}::a', 'diff', 'TODO_a', 'b', '--bypass-lock')
 
     def test_readonly_export_tar(self):
-        self.cmd('init', '--encryption=repokey', self.repository_location)
+        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
         self.create_src_archive('test')
         with self.read_only(self.repository_path):
             # verify that command normally doesn't work with read-only repo
             if self.FORK_DEFAULT:
-                self.cmd('export-tar', '%s::test' % self.repository_location, 'test.tar', exit_code=EXIT_ERROR)
+                self.cmd(f'--repo={self.repository_location}::test', 'export-tar', 'test.tar', exit_code=EXIT_ERROR)
             else:
                 with pytest.raises((LockFailed, RemoteRepository.RPCError)) as excinfo:
-                    self.cmd('export-tar', '%s::test' % self.repository_location, 'test.tar')
+                    self.cmd(f'--repo={self.repository_location}::test', 'export-tar', 'test.tar')
                 if isinstance(excinfo.value, RemoteRepository.RPCError):
                     assert excinfo.value.exception_class == 'LockFailed'
             # verify that command works with read-only repo when using --bypass-lock
-            self.cmd('export-tar', '%s::test' % self.repository_location, 'test.tar', '--bypass-lock')
+            self.cmd(f'--repo={self.repository_location}::test', 'export-tar', 'test.tar', '--bypass-lock')
 
     def test_readonly_extract(self):
-        self.cmd('init', '--encryption=repokey', self.repository_location)
+        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
         self.create_src_archive('test')
         with self.read_only(self.repository_path):
             # verify that command normally doesn't work with read-only repo
             if self.FORK_DEFAULT:
-                self.cmd('extract', '%s::test' % self.repository_location, exit_code=EXIT_ERROR)
+                self.cmd(f'--repo={self.repository_location}::test', 'extract', exit_code=EXIT_ERROR)
             else:
                 with pytest.raises((LockFailed, RemoteRepository.RPCError)) as excinfo:
-                    self.cmd('extract', '%s::test' % self.repository_location)
+                    self.cmd(f'--repo={self.repository_location}::test', 'extract')
                 if isinstance(excinfo.value, RemoteRepository.RPCError):
                     assert excinfo.value.exception_class == 'LockFailed'
             # verify that command works with read-only repo when using --bypass-lock
-            self.cmd('extract', '%s::test' % self.repository_location, '--bypass-lock')
+            self.cmd(f'--repo={self.repository_location}::test', 'extract', '--bypass-lock')
 
     def test_readonly_info(self):
-        self.cmd('init', '--encryption=repokey', self.repository_location)
+        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
         self.create_src_archive('test')
         with self.read_only(self.repository_path):
             # verify that command normally doesn't work with read-only repo
             if self.FORK_DEFAULT:
-                self.cmd('info', self.repository_location, exit_code=EXIT_ERROR)
+                self.cmd(f'--repo={self.repository_location}', 'info', exit_code=EXIT_ERROR)
             else:
                 with pytest.raises((LockFailed, RemoteRepository.RPCError)) as excinfo:
-                    self.cmd('info', self.repository_location)
+                    self.cmd(f'--repo={self.repository_location}', 'info')
                 if isinstance(excinfo.value, RemoteRepository.RPCError):
                     assert excinfo.value.exception_class == 'LockFailed'
             # verify that command works with read-only repo when using --bypass-lock
-            self.cmd('info', self.repository_location, '--bypass-lock')
+            self.cmd(f'--repo={self.repository_location}', 'info', '--bypass-lock')
 
     def test_readonly_list(self):
-        self.cmd('init', '--encryption=repokey', self.repository_location)
+        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
         self.create_src_archive('test')
         with self.read_only(self.repository_path):
             # verify that command normally doesn't work with read-only repo
             if self.FORK_DEFAULT:
-                self.cmd('list', self.repository_location, exit_code=EXIT_ERROR)
+                self.cmd(f'--repo={self.repository_location}', 'list', exit_code=EXIT_ERROR)
             else:
                 with pytest.raises((LockFailed, RemoteRepository.RPCError)) as excinfo:
-                    self.cmd('list', self.repository_location)
+                    self.cmd(f'--repo={self.repository_location}', 'list')
                 if isinstance(excinfo.value, RemoteRepository.RPCError):
                     assert excinfo.value.exception_class == 'LockFailed'
             # verify that command works with read-only repo when using --bypass-lock
-            self.cmd('list', self.repository_location, '--bypass-lock')
+            self.cmd(f'--repo={self.repository_location}', 'list', '--bypass-lock')
 
     @unittest.skipUnless(llfuse, 'llfuse not installed')
     def test_readonly_mount(self):
-        self.cmd('init', '--encryption=repokey', self.repository_location)
+        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
         self.create_src_archive('test')
         with self.read_only(self.repository_path):
             # verify that command normally doesn't work with read-only repo
@@ -1794,14 +1794,14 @@ class ArchiverTestCase(ArchiverTestCaseBase):
     @pytest.mark.skipif('BORG_TESTS_IGNORE_MODES' in os.environ, reason='modes unreliable')
     def test_umask(self):
         self.create_regular_file('file1', size=1024 * 80)
-        self.cmd('init', '--encryption=repokey', self.repository_location)
-        self.cmd('create', self.repository_location + '::test', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}::test', 'create', 'input')
         mode = os.stat(self.repository_path).st_mode
         self.assertEqual(stat.S_IMODE(mode), 0o700)
 
     def test_create_dry_run(self):
-        self.cmd('init', '--encryption=repokey', self.repository_location)
-        self.cmd('create', '--dry-run', self.repository_location + '::test', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}::test', 'create', '--dry-run', 'input')
         # Make sure no archive has been created
         with Repository(self.repository_path) as repository:
             manifest, key = Manifest.load(repository, Manifest.NO_OPERATION_CHECK)
@@ -1823,56 +1823,56 @@ class ArchiverTestCase(ArchiverTestCaseBase):
             assert excinfo.value.args == (['unknown-feature'],)
 
     def test_unknown_feature_on_create(self):
-        print(self.cmd('init', '--encryption=repokey', self.repository_location))
+        print(self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey'))
         self.add_unknown_feature(Manifest.Operation.WRITE)
-        self.cmd_raises_unknown_feature(['create', self.repository_location + '::test', 'input'])
+        self.cmd_raises_unknown_feature([f'--repo={self.repository_location}::test', 'create', 'input'])
 
     def test_unknown_feature_on_cache_sync(self):
-        self.cmd('init', '--encryption=repokey', self.repository_location)
-        self.cmd('delete', '--cache-only', self.repository_location)
+        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'delete', '--cache-only')
         self.add_unknown_feature(Manifest.Operation.READ)
-        self.cmd_raises_unknown_feature(['create', self.repository_location + '::test', 'input'])
+        self.cmd_raises_unknown_feature([f'--repo={self.repository_location}::test', 'create', 'input'])
 
     def test_unknown_feature_on_change_passphrase(self):
-        print(self.cmd('init', '--encryption=repokey', self.repository_location))
+        print(self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey'))
         self.add_unknown_feature(Manifest.Operation.CHECK)
-        self.cmd_raises_unknown_feature(['key', 'change-passphrase', self.repository_location])
+        self.cmd_raises_unknown_feature([f'--repo={self.repository_location}', 'key', 'change-passphrase'])
 
     def test_unknown_feature_on_read(self):
-        print(self.cmd('init', '--encryption=repokey', self.repository_location))
-        self.cmd('create', self.repository_location + '::test', 'input')
+        print(self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey'))
+        self.cmd(f'--repo={self.repository_location}::test', 'create', 'input')
         self.add_unknown_feature(Manifest.Operation.READ)
         with changedir('output'):
-            self.cmd_raises_unknown_feature(['extract', self.repository_location + '::test'])
+            self.cmd_raises_unknown_feature([f'--repo={self.repository_location}::test', 'extract'])
 
-        self.cmd_raises_unknown_feature(['list', self.repository_location])
-        self.cmd_raises_unknown_feature(['info', self.repository_location + '::test'])
+        self.cmd_raises_unknown_feature([f'--repo={self.repository_location}', 'list'])
+        self.cmd_raises_unknown_feature([f'--repo={self.repository_location}::test', 'info'])
 
     def test_unknown_feature_on_rename(self):
-        print(self.cmd('init', '--encryption=repokey', self.repository_location))
-        self.cmd('create', self.repository_location + '::test', 'input')
+        print(self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey'))
+        self.cmd(f'--repo={self.repository_location}::test', 'create', 'input')
         self.add_unknown_feature(Manifest.Operation.CHECK)
-        self.cmd_raises_unknown_feature(['rename', self.repository_location + '::test', 'other'])
+        self.cmd_raises_unknown_feature([f'--repo={self.repository_location}::test', 'rename', 'TODO_test', 'other'])
 
     def test_unknown_feature_on_delete(self):
-        print(self.cmd('init', '--encryption=repokey', self.repository_location))
-        self.cmd('create', self.repository_location + '::test', 'input')
+        print(self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey'))
+        self.cmd(f'--repo={self.repository_location}::test', 'create', 'input')
         self.add_unknown_feature(Manifest.Operation.DELETE)
         # delete of an archive raises
-        self.cmd_raises_unknown_feature(['delete', self.repository_location + '::test'])
-        self.cmd_raises_unknown_feature(['prune', '--keep-daily=3', self.repository_location])
+        self.cmd_raises_unknown_feature([f'--repo={self.repository_location}::test', 'delete'])
+        self.cmd_raises_unknown_feature([f'--repo={self.repository_location}', 'prune', '--keep-daily=3'])
         # delete of the whole repository ignores features
-        self.cmd('delete', self.repository_location)
+        self.cmd(f'--repo={self.repository_location}', 'delete')
 
     @unittest.skipUnless(llfuse, 'llfuse not installed')
     def test_unknown_feature_on_mount(self):
-        self.cmd('init', '--encryption=repokey', self.repository_location)
-        self.cmd('create', self.repository_location + '::test', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}::test', 'create', 'input')
         self.add_unknown_feature(Manifest.Operation.READ)
         mountpoint = os.path.join(self.tmpdir, 'mountpoint')
         os.mkdir(mountpoint)
         # XXX this might hang if it doesn't raise an error
-        self.cmd_raises_unknown_feature(['mount', self.repository_location + '::test', mountpoint])
+        self.cmd_raises_unknown_feature([f'--repo={self.repository_location}::test', 'mount', mountpoint])
 
     @pytest.mark.allow_cache_wipe
     def test_unknown_mandatory_feature_in_cache(self):
@@ -1881,7 +1881,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         else:
             path_prefix = ''
 
-        print(self.cmd('init', '--encryption=repokey', self.repository_location))
+        print(self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey'))
 
         with Repository(self.repository_path, exclusive=True) as repository:
             if path_prefix:
@@ -1893,7 +1893,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
                 cache.commit()
 
         if self.FORK_DEFAULT:
-            self.cmd('create', self.repository_location + '::test', 'input')
+            self.cmd(f'--repo={self.repository_location}::test', 'create', 'input')
         else:
             called = False
             wipe_cache_safe = LocalCache.wipe_cache
@@ -1904,7 +1904,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
                 wipe_cache_safe(*args)
 
             with patch.object(LocalCache, 'wipe_cache', wipe_wrapper):
-                self.cmd('create', self.repository_location + '::test', 'input')
+                self.cmd(f'--repo={self.repository_location}::test', 'create', 'input')
 
             assert called
 
@@ -1917,14 +1917,14 @@ class ArchiverTestCase(ArchiverTestCaseBase):
 
     def test_progress_on(self):
         self.create_regular_file('file1', size=1024 * 80)
-        self.cmd('init', '--encryption=repokey', self.repository_location)
-        output = self.cmd('create', '--progress', self.repository_location + '::test4', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        output = self.cmd(f'--repo={self.repository_location}::test4', 'create', '--progress', 'input')
         self.assert_in("\r", output)
 
     def test_progress_off(self):
         self.create_regular_file('file1', size=1024 * 80)
-        self.cmd('init', '--encryption=repokey', self.repository_location)
-        output = self.cmd('create', self.repository_location + '::test5', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        output = self.cmd(f'--repo={self.repository_location}::test5', 'create', 'input')
         self.assert_not_in("\r", output)
 
     def test_file_status(self):
@@ -1934,12 +1934,12 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self.create_regular_file('file1', size=1024 * 80)
         time.sleep(1)  # file2 must have newer timestamps than file1
         self.create_regular_file('file2', size=1024 * 80)
-        self.cmd('init', '--encryption=repokey', self.repository_location)
-        output = self.cmd('create', '--list', self.repository_location + '::test', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        output = self.cmd(f'--repo={self.repository_location}::test', 'create', '--list', 'input')
         self.assert_in("A input/file1", output)
         self.assert_in("A input/file2", output)
         # should find first file as unmodified
-        output = self.cmd('create', '--list', self.repository_location + '::test1', 'input')
+        output = self.cmd(f'--repo={self.repository_location}::test1', 'create', '--list', 'input')
         self.assert_in("U input/file1", output)
         # this is expected, although surprising, for why, see:
         # https://borgbackup.readthedocs.org/en/latest/faq.html#i-am-seeing-a-added-status-for-a-unchanged-file
@@ -1950,14 +1950,16 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self.create_regular_file('file1', contents=b'123')
         time.sleep(1)  # file2 must have newer timestamps than file1
         self.create_regular_file('file2', size=10)
-        self.cmd('init', '--encryption=repokey', self.repository_location)
-        output = self.cmd('create', '--list', '--files-cache=ctime,size', self.repository_location + '::test1', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        output = self.cmd(f'--repo={self.repository_location}::test1', 'create',
+                          '--list', '--files-cache=ctime,size', 'input')
         # modify file1, but cheat with the mtime (and atime) and also keep same size:
         st = os.stat('input/file1')
         self.create_regular_file('file1', contents=b'321')
         os.utime('input/file1', ns=(st.st_atime_ns, st.st_mtime_ns))
         # this mode uses ctime for change detection, so it should find file1 as modified
-        output = self.cmd('create', '--list', '--files-cache=ctime,size', self.repository_location + '::test2', 'input')
+        output = self.cmd(f'--repo={self.repository_location}::test2', 'create',
+                          '--list', '--files-cache=ctime,size', 'input')
         self.assert_in("M input/file1", output)
 
     def test_file_status_ms_cache_mode(self):
@@ -1965,13 +1967,15 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self.create_regular_file('file1', size=10)
         time.sleep(1)  # file2 must have newer timestamps than file1
         self.create_regular_file('file2', size=10)
-        self.cmd('init', '--encryption=repokey', self.repository_location)
-        output = self.cmd('create', '--list', '--files-cache=mtime,size', self.repository_location + '::test1', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        output = self.cmd(f'--repo={self.repository_location}::test1', 'create',
+                          '--list', '--files-cache=mtime,size', 'input')
         # change mode of file1, no content change:
         st = os.stat('input/file1')
         os.chmod('input/file1', st.st_mode ^ stat.S_IRWXO)  # this triggers a ctime change, but mtime is unchanged
         # this mode uses mtime for change detection, so it should find file1 as unmodified
-        output = self.cmd('create', '--list', '--files-cache=mtime,size', self.repository_location + '::test2', 'input')
+        output = self.cmd(f'--repo={self.repository_location}::test2', 'create',
+                          '--list', '--files-cache=mtime,size', 'input')
         self.assert_in("U input/file1", output)
 
     def test_file_status_rc_cache_mode(self):
@@ -1979,10 +1983,12 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self.create_regular_file('file1', size=10)
         time.sleep(1)  # file2 must have newer timestamps than file1
         self.create_regular_file('file2', size=10)
-        self.cmd('init', '--encryption=repokey', self.repository_location)
-        output = self.cmd('create', '--list', '--files-cache=rechunk,ctime', self.repository_location + '::test1', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        output = self.cmd(f'--repo={self.repository_location}::test1', 'create',
+                          '--list', '--files-cache=rechunk,ctime', 'input')
         # no changes here, but this mode rechunks unconditionally
-        output = self.cmd('create', '--list', '--files-cache=rechunk,ctime', self.repository_location + '::test2', 'input')
+        output = self.cmd(f'--repo={self.repository_location}::test2', 'create',
+                          '--list', '--files-cache=rechunk,ctime', 'input')
         self.assert_in("A input/file1", output)
 
     def test_file_status_excluded(self):
@@ -1994,14 +2000,15 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         if has_lchflags:
             self.create_regular_file('file3', size=1024 * 80)
             platform.set_flags(os.path.join(self.input_path, 'file3'), stat.UF_NODUMP)
-        self.cmd('init', '--encryption=repokey', self.repository_location)
-        output = self.cmd('create', '--list', '--exclude-nodump', self.repository_location + '::test', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        output = self.cmd(f'--repo={self.repository_location}::test', 'create', '--list', '--exclude-nodump', 'input')
         self.assert_in("A input/file1", output)
         self.assert_in("A input/file2", output)
         if has_lchflags:
             self.assert_in("x input/file3", output)
         # should find second file as excluded
-        output = self.cmd('create', '--list', '--exclude-nodump', self.repository_location + '::test1', 'input', '--exclude', '*/file2')
+        output = self.cmd(f'--repo={self.repository_location}::test1', 'create',
+                          '--list', '--exclude-nodump', 'input', '--exclude', '*/file2')
         self.assert_in("U input/file1", output)
         self.assert_in("x input/file2", output)
         if has_lchflags:
@@ -2009,8 +2016,9 @@ class ArchiverTestCase(ArchiverTestCaseBase):
 
     def test_create_json(self):
         self.create_regular_file('file1', size=1024 * 80)
-        self.cmd('init', '--encryption=repokey', self.repository_location)
-        create_info = json.loads(self.cmd('create', '--json', self.repository_location + '::test', 'input'))
+        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        create_info = json.loads(self.cmd(f'--repo={self.repository_location}::test', 'create',
+                                          '--json', 'input'))
         # The usual keys
         assert 'encryption' in create_info
         assert 'repository' in create_info
@@ -2028,23 +2036,23 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self.create_regular_file('file1', size=1024 * 80)
         time.sleep(1)  # file2 must have newer timestamps than file1
         self.create_regular_file('file2', size=1024 * 80)
-        self.cmd('init', '--encryption=repokey', self.repository_location)
+        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
         # no listing by default
-        output = self.cmd('create', self.repository_location + '::test', 'input')
+        output = self.cmd(f'--repo={self.repository_location}::test', 'create', 'input')
         self.assert_not_in('file1', output)
         # shouldn't be listed even if unchanged
-        output = self.cmd('create', self.repository_location + '::test0', 'input')
+        output = self.cmd(f'--repo={self.repository_location}::test0', 'create', 'input')
         self.assert_not_in('file1', output)
         # should list the file as unchanged
-        output = self.cmd('create', '--list', '--filter=U', self.repository_location + '::test1', 'input')
+        output = self.cmd(f'--repo={self.repository_location}::test1', 'create', '--list', '--filter=U', 'input')
         self.assert_in('file1', output)
         # should *not* list the file as changed
-        output = self.cmd('create', '--list', '--filter=AM', self.repository_location + '::test2', 'input')
+        output = self.cmd(f'--repo={self.repository_location}::test2', 'create', '--list', '--filter=AM', 'input')
         self.assert_not_in('file1', output)
         # change the file
         self.create_regular_file('file1', size=1024 * 100)
         # should list the file as changed
-        output = self.cmd('create', '--list', '--filter=AM', self.repository_location + '::test3', 'input')
+        output = self.cmd(f'--repo={self.repository_location}::test3', 'create', '--list', '--filter=AM', 'input')
         self.assert_in('file1', output)
 
     @pytest.mark.skipif(not are_fifos_supported(), reason='FIFOs not supported')
@@ -2058,8 +2066,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
             finally:
                 os.close(fd)
 
-        self.cmd('init', '--encryption=repokey', self.repository_location)
-        archive = self.repository_location + '::test'
+        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
         data = b'foobar' * 1000
 
         fifo_fn = os.path.join(self.input_path, 'fifo')
@@ -2070,11 +2077,11 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         t = Thread(target=fifo_feeder, args=(fifo_fn, data))
         t.start()
         try:
-            self.cmd('create', '--read-special', archive, 'input/link_fifo')
+            self.cmd(f'--repo={self.repository_location}::test', 'create', '--read-special', 'input/link_fifo')
         finally:
             t.join()
         with changedir('output'):
-            self.cmd('extract', archive)
+            self.cmd(f'--repo={self.repository_location}::test', 'extract')
             fifo_fn = 'input/link_fifo'
             with open(fifo_fn, 'rb') as f:
                 extracted_data = f.read()
@@ -2082,41 +2089,40 @@ class ArchiverTestCase(ArchiverTestCaseBase):
 
     def test_create_read_special_broken_symlink(self):
         os.symlink('somewhere does not exist', os.path.join(self.input_path, 'link'))
-        self.cmd('init', '--encryption=repokey', self.repository_location)
-        archive = self.repository_location + '::test'
-        self.cmd('create', '--read-special', archive, 'input')
-        output = self.cmd('list', archive)
+        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}::test', 'create', '--read-special', 'input')
+        output = self.cmd(f'--repo={self.repository_location}::test', 'list')
         assert 'input/link -> somewhere does not exist' in output
 
     # def test_cmdline_compatibility(self):
     #    self.create_regular_file('file1', size=1024 * 80)
-    #    self.cmd('init', '--encryption=repokey', self.repository_location)
+    #    self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
     #    self.cmd('create', self.repository_location + '::test', 'input')
     #    output = self.cmd('foo', self.repository_location, '--old')
     #    self.assert_in('"--old" has been deprecated. Use "--new" instead', output)
 
     def test_prune_repository(self):
-        self.cmd('init', '--encryption=repokey', self.repository_location)
-        self.cmd('create', self.repository_location + '::test1', src_dir)
-        self.cmd('create', self.repository_location + '::test2', src_dir)
+        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}::test1', 'create', src_dir)
+        self.cmd(f'--repo={self.repository_location}::test2', 'create', src_dir)
         # these are not really a checkpoints, but they look like some:
-        self.cmd('create', self.repository_location + '::test3.checkpoint', src_dir)
-        self.cmd('create', self.repository_location + '::test3.checkpoint.1', src_dir)
-        self.cmd('create', self.repository_location + '::test4.checkpoint', src_dir)
-        output = self.cmd('prune', '--list', '--dry-run', self.repository_location, '--keep-daily=1')
+        self.cmd(f'--repo={self.repository_location}::test3.checkpoint', 'create', src_dir)
+        self.cmd(f'--repo={self.repository_location}::test3.checkpoint.1', 'create', src_dir)
+        self.cmd(f'--repo={self.repository_location}::test4.checkpoint', 'create', src_dir)
+        output = self.cmd(f'--repo={self.repository_location}', 'prune', '--list', '--dry-run', '--keep-daily=1')
         assert re.search(r'Would prune:\s+test1', output)
         # must keep the latest non-checkpoint archive:
         assert re.search(r'Keeping archive \(rule: daily #1\):\s+test2', output)
         # must keep the latest checkpoint archive:
         assert re.search(r'Keeping checkpoint archive:\s+test4.checkpoint', output)
-        output = self.cmd('list', '--consider-checkpoints', self.repository_location)
+        output = self.cmd(f'--repo={self.repository_location}', 'list', '--consider-checkpoints')
         self.assert_in('test1', output)
         self.assert_in('test2', output)
         self.assert_in('test3.checkpoint', output)
         self.assert_in('test3.checkpoint.1', output)
         self.assert_in('test4.checkpoint', output)
-        self.cmd('prune', self.repository_location, '--keep-daily=1')
-        output = self.cmd('list', '--consider-checkpoints', self.repository_location)
+        self.cmd(f'--repo={self.repository_location}', 'prune', '--keep-daily=1')
+        output = self.cmd(f'--repo={self.repository_location}', 'list', '--consider-checkpoints')
         self.assert_not_in('test1', output)
         # the latest non-checkpoint archive must be still there:
         self.assert_in('test2', output)
@@ -2125,9 +2131,9 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self.assert_not_in('test3.checkpoint.1', output)
         self.assert_in('test4.checkpoint', output)
         # now we supersede the latest checkpoint by a successful backup:
-        self.cmd('create', self.repository_location + '::test5', src_dir)
-        self.cmd('prune', self.repository_location, '--keep-daily=2')
-        output = self.cmd('list', '--consider-checkpoints', self.repository_location)
+        self.cmd(f'--repo={self.repository_location}::test5', 'create', src_dir)
+        self.cmd(f'--repo={self.repository_location}', 'prune', '--keep-daily=2')
+        output = self.cmd(f'--repo={self.repository_location}', 'list', '--consider-checkpoints')
         # all checkpoints should be gone now:
         self.assert_not_in('checkpoint', output)
         # the latest archive must be still there
@@ -2140,12 +2146,12 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         return dtime.astimezone(dateutil.tz.UTC).strftime("%Y-%m-%dT%H:%M:%S")
 
     def _create_archive_ts(self, name, y, m, d, H=0, M=0, S=0):
-        loc = self.repository_location + '::' + name
-        self.cmd('create', '--timestamp', self._to_utc_timestamp(y, m, d, H, M, S), loc, src_dir)
+        self.cmd(f'--repo={self.repository_location}::{name}', 'create',
+                 '--timestamp', self._to_utc_timestamp(y, m, d, H, M, S), src_dir)
 
     # This test must match docs/misc/prune-example.txt
     def test_prune_repository_example(self):
-        self.cmd('init', '--encryption=repokey', self.repository_location)
+        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
         # Archives that will be kept, per the example
         # Oldest archive
         self._create_archive_ts('test01', 2015, 1, 1)
@@ -2178,7 +2184,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self._create_archive_ts('test23', 2015, 5, 31)
         # The next older daily backup
         self._create_archive_ts('test24', 2015, 12, 16)
-        output = self.cmd('prune', '--list', '--dry-run', self.repository_location, '--keep-daily=14', '--keep-monthly=6', '--keep-yearly=1')
+        output = self.cmd(f'--repo={self.repository_location}', 'prune', '--list', '--dry-run', '--keep-daily=14', '--keep-monthly=6', '--keep-yearly=1')
         # Prune second backup of the year
         assert re.search(r'Would prune:\s+test22', output)
         # Prune next older monthly and daily backups
@@ -2191,12 +2197,12 @@ class ArchiverTestCase(ArchiverTestCaseBase):
             assert re.search(r'Keeping archive \(rule: monthly #' + str(i) + r'\):\s+test' + ("%02d" % (8-i)), output)
         for i in range(1, 15):
             assert re.search(r'Keeping archive \(rule: daily #' + str(i) + r'\):\s+test' + ("%02d" % (22-i)), output)
-        output = self.cmd('list', self.repository_location)
+        output = self.cmd(f'--repo={self.repository_location}', 'list')
         # Nothing pruned after dry run
         for i in range(1, 25):
             self.assert_in('test%02d' % i, output)
-        self.cmd('prune', self.repository_location, '--keep-daily=14', '--keep-monthly=6', '--keep-yearly=1')
-        output = self.cmd('list', self.repository_location)
+        self.cmd(f'--repo={self.repository_location}', 'prune', '--keep-daily=14', '--keep-monthly=6', '--keep-yearly=1')
+        output = self.cmd(f'--repo={self.repository_location}', 'list')
         # All matching backups plus oldest kept
         for i in range(1, 22):
             self.assert_in('test%02d' % i, output)
@@ -2206,141 +2212,139 @@ class ArchiverTestCase(ArchiverTestCaseBase):
 
     # With an initial and daily backup, prune daily until oldest is replaced by a monthly backup
     def test_prune_retain_and_expire_oldest(self):
-        self.cmd('init', '--encryption=repokey', self.repository_location)
+        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
         # Initial backup
         self._create_archive_ts('original_archive', 2020, 9, 1, 11, 15)
         # Archive and prune daily for 30 days
         for i in range(1, 31):
             self._create_archive_ts('september%02d' % i, 2020, 9, i, 12)
-            self.cmd('prune', self.repository_location, '--keep-daily=7', '--keep-monthly=1')
+            self.cmd(f'--repo={self.repository_location}', 'prune', '--keep-daily=7', '--keep-monthly=1')
         # Archive and prune 6 days into the next month
         for i in range(1, 7):
             self._create_archive_ts('october%02d' % i, 2020, 10, i, 12)
-            self.cmd('prune', self.repository_location, '--keep-daily=7', '--keep-monthly=1')
+            self.cmd(f'--repo={self.repository_location}', 'prune', '--keep-daily=7', '--keep-monthly=1')
         # Oldest backup is still retained
-        output = self.cmd('prune', '--list', '--dry-run', self.repository_location, '--keep-daily=7', '--keep-monthly=1')
+        output = self.cmd(f'--repo={self.repository_location}', 'prune', '--list', '--dry-run', '--keep-daily=7', '--keep-monthly=1')
         assert re.search(r'Keeping archive \(rule: monthly\[oldest\] #1' + r'\):\s+original_archive', output)
         # Archive one more day and prune.
         self._create_archive_ts('october07', 2020, 10, 7, 12)
-        self.cmd('prune', self.repository_location, '--keep-daily=7', '--keep-monthly=1')
+        self.cmd(f'--repo={self.repository_location}', 'prune', '--keep-daily=7', '--keep-monthly=1')
         # Last day of previous month is retained as monthly, and oldest is expired.
-        output = self.cmd('prune', '--list', '--dry-run', self.repository_location, '--keep-daily=7', '--keep-monthly=1')
+        output = self.cmd(f'--repo={self.repository_location}', 'prune', '--list', '--dry-run', '--keep-daily=7', '--keep-monthly=1')
         assert re.search(r'Keeping archive \(rule: monthly #1\):\s+september30', output)
         self.assert_not_in('original_archive', output)
 
     def test_prune_repository_save_space(self):
-        self.cmd('init', '--encryption=repokey', self.repository_location)
-        self.cmd('create', self.repository_location + '::test1', src_dir)
-        self.cmd('create', self.repository_location + '::test2', src_dir)
-        output = self.cmd('prune', '--list', '--dry-run', self.repository_location, '--keep-daily=1')
+        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}::test1', 'create', src_dir)
+        self.cmd(f'--repo={self.repository_location}::test2', 'create', src_dir)
+        output = self.cmd(f'--repo={self.repository_location}', 'prune', '--list', '--dry-run', '--keep-daily=1')
         assert re.search(r'Keeping archive \(rule: daily #1\):\s+test2', output)
         assert re.search(r'Would prune:\s+test1', output)
-        output = self.cmd('list', self.repository_location)
+        output = self.cmd(f'--repo={self.repository_location}', 'list')
         self.assert_in('test1', output)
         self.assert_in('test2', output)
-        self.cmd('prune', '--save-space', self.repository_location, '--keep-daily=1')
-        output = self.cmd('list', self.repository_location)
+        self.cmd(f'--repo={self.repository_location}', 'prune', '--save-space', '--keep-daily=1')
+        output = self.cmd(f'--repo={self.repository_location}', 'list')
         self.assert_not_in('test1', output)
         self.assert_in('test2', output)
 
     def test_prune_repository_prefix(self):
-        self.cmd('init', '--encryption=repokey', self.repository_location)
-        self.cmd('create', self.repository_location + '::foo-2015-08-12-10:00', src_dir)
-        self.cmd('create', self.repository_location + '::foo-2015-08-12-20:00', src_dir)
-        self.cmd('create', self.repository_location + '::bar-2015-08-12-10:00', src_dir)
-        self.cmd('create', self.repository_location + '::bar-2015-08-12-20:00', src_dir)
-        output = self.cmd('prune', '--list', '--dry-run', self.repository_location, '--keep-daily=1', '--prefix=foo-')
+        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}::foo-2015-08-12-10:00', 'create', src_dir)
+        self.cmd(f'--repo={self.repository_location}::foo-2015-08-12-20:00', 'create', src_dir)
+        self.cmd(f'--repo={self.repository_location}::bar-2015-08-12-10:00', 'create', src_dir)
+        self.cmd(f'--repo={self.repository_location}::bar-2015-08-12-20:00', 'create', src_dir)
+        output = self.cmd(f'--repo={self.repository_location}', 'prune', '--list', '--dry-run', '--keep-daily=1', '--prefix=foo-')
         assert re.search(r'Keeping archive \(rule: daily #1\):\s+foo-2015-08-12-20:00', output)
         assert re.search(r'Would prune:\s+foo-2015-08-12-10:00', output)
-        output = self.cmd('list', self.repository_location)
+        output = self.cmd(f'--repo={self.repository_location}', 'list')
         self.assert_in('foo-2015-08-12-10:00', output)
         self.assert_in('foo-2015-08-12-20:00', output)
         self.assert_in('bar-2015-08-12-10:00', output)
         self.assert_in('bar-2015-08-12-20:00', output)
-        self.cmd('prune', self.repository_location, '--keep-daily=1', '--prefix=foo-')
-        output = self.cmd('list', self.repository_location)
+        self.cmd(f'--repo={self.repository_location}', 'prune', '--keep-daily=1', '--prefix=foo-')
+        output = self.cmd(f'--repo={self.repository_location}', 'list')
         self.assert_not_in('foo-2015-08-12-10:00', output)
         self.assert_in('foo-2015-08-12-20:00', output)
         self.assert_in('bar-2015-08-12-10:00', output)
         self.assert_in('bar-2015-08-12-20:00', output)
 
     def test_prune_repository_glob(self):
-        self.cmd('init', '--encryption=repokey', self.repository_location)
-        self.cmd('create', self.repository_location + '::2015-08-12-10:00-foo', src_dir)
-        self.cmd('create', self.repository_location + '::2015-08-12-20:00-foo', src_dir)
-        self.cmd('create', self.repository_location + '::2015-08-12-10:00-bar', src_dir)
-        self.cmd('create', self.repository_location + '::2015-08-12-20:00-bar', src_dir)
-        output = self.cmd('prune', '--list', '--dry-run', self.repository_location, '--keep-daily=1', '--glob-archives=2015-*-foo')
+        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}::2015-08-12-10:00-foo', 'create', src_dir)
+        self.cmd(f'--repo={self.repository_location}::2015-08-12-20:00-foo', 'create', src_dir)
+        self.cmd(f'--repo={self.repository_location}::2015-08-12-10:00-bar', 'create', src_dir)
+        self.cmd(f'--repo={self.repository_location}::2015-08-12-20:00-bar', 'create', src_dir)
+        output = self.cmd(f'--repo={self.repository_location}', 'prune', '--list', '--dry-run', '--keep-daily=1', '--glob-archives=2015-*-foo')
         assert re.search(r'Keeping archive \(rule: daily #1\):\s+2015-08-12-20:00-foo', output)
         assert re.search(r'Would prune:\s+2015-08-12-10:00-foo', output)
-        output = self.cmd('list', self.repository_location)
+        output = self.cmd(f'--repo={self.repository_location}', 'list')
         self.assert_in('2015-08-12-10:00-foo', output)
         self.assert_in('2015-08-12-20:00-foo', output)
         self.assert_in('2015-08-12-10:00-bar', output)
         self.assert_in('2015-08-12-20:00-bar', output)
-        self.cmd('prune', self.repository_location, '--keep-daily=1', '--glob-archives=2015-*-foo')
-        output = self.cmd('list', self.repository_location)
+        self.cmd(f'--repo={self.repository_location}', 'prune', '--keep-daily=1', '--glob-archives=2015-*-foo')
+        output = self.cmd(f'--repo={self.repository_location}', 'list')
         self.assert_not_in('2015-08-12-10:00-foo', output)
         self.assert_in('2015-08-12-20:00-foo', output)
         self.assert_in('2015-08-12-10:00-bar', output)
         self.assert_in('2015-08-12-20:00-bar', output)
 
     def test_list_prefix(self):
-        self.cmd('init', '--encryption=repokey', self.repository_location)
-        self.cmd('create', self.repository_location + '::test-1', src_dir)
-        self.cmd('create', self.repository_location + '::something-else-than-test-1', src_dir)
-        self.cmd('create', self.repository_location + '::test-2', src_dir)
-        output = self.cmd('list', '--prefix=test-', self.repository_location)
+        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}::test-1', 'create', src_dir)
+        self.cmd(f'--repo={self.repository_location}::something-else-than-test-1', 'create', src_dir)
+        self.cmd(f'--repo={self.repository_location}::test-2', 'create', src_dir)
+        output = self.cmd(f'--repo={self.repository_location}', 'list', '--prefix=test-')
         self.assert_in('test-1', output)
         self.assert_in('test-2', output)
         self.assert_not_in('something-else', output)
 
     def test_list_format(self):
-        self.cmd('init', '--encryption=repokey', self.repository_location)
-        test_archive = self.repository_location + '::test'
-        self.cmd('create', test_archive, src_dir)
-        output_1 = self.cmd('list', test_archive)
-        output_2 = self.cmd('list', '--format', '{mode} {user:6} {group:6} {size:8d} {mtime} {path}{extra}{NEWLINE}', test_archive)
-        output_3 = self.cmd('list', '--format', '{mtime:%s} {path}{NL}', test_archive)
+        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}::test', 'create', src_dir)
+        output_1 = self.cmd(f'--repo={self.repository_location}::test', 'list')
+        output_2 = self.cmd(f'--repo={self.repository_location}::test', 'list', '--format', '{mode} {user:6} {group:6} {size:8d} {mtime} {path}{extra}{NEWLINE}')
+        output_3 = self.cmd(f'--repo={self.repository_location}::test', 'list', '--format', '{mtime:%s} {path}{NL}')
         self.assertEqual(output_1, output_2)
         self.assertNotEqual(output_1, output_3)
 
     def test_list_repository_format(self):
-        self.cmd('init', '--encryption=repokey', self.repository_location)
-        self.cmd('create', '--comment', 'comment 1', self.repository_location + '::test-1', src_dir)
-        self.cmd('create', '--comment', 'comment 2', self.repository_location + '::test-2', src_dir)
-        output_1 = self.cmd('list', self.repository_location)
-        output_2 = self.cmd('list', '--format', '{archive:<36} {time} [{id}]{NL}', self.repository_location)
+        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}::test-1', 'create', '--comment', 'comment 1', src_dir)
+        self.cmd(f'--repo={self.repository_location}::test-2', 'create', '--comment', 'comment 2', src_dir)
+        output_1 = self.cmd(f'--repo={self.repository_location}', 'list')
+        output_2 = self.cmd(f'--repo={self.repository_location}', 'list', '--format', '{archive:<36} {time} [{id}]{NL}')
         self.assertEqual(output_1, output_2)
-        output_1 = self.cmd('list', '--short', self.repository_location)
+        output_1 = self.cmd(f'--repo={self.repository_location}', 'list', '--short')
         self.assertEqual(output_1, 'test-1\ntest-2\n')
-        output_1 = self.cmd('list', '--format', '{barchive}/', self.repository_location)
+        output_1 = self.cmd(f'--repo={self.repository_location}', 'list', '--format', '{barchive}/')
         self.assertEqual(output_1, 'test-1/test-2/')
-        output_3 = self.cmd('list', '--format', '{name} {comment}{NL}', self.repository_location)
+        output_3 = self.cmd(f'--repo={self.repository_location}', 'list', '--format', '{name} {comment}{NL}')
         self.assert_in('test-1 comment 1\n', output_3)
         self.assert_in('test-2 comment 2\n', output_3)
 
     def test_list_hash(self):
         self.create_regular_file('empty_file', size=0)
         self.create_regular_file('amb', contents=b'a' * 1000000)
-        self.cmd('init', '--encryption=repokey', self.repository_location)
-        test_archive = self.repository_location + '::test'
-        self.cmd('create', test_archive, 'input')
-        output = self.cmd('list', '--format', '{sha256} {path}{NL}', test_archive)
+        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}::test', 'create', 'input')
+        output = self.cmd(f'--repo={self.repository_location}::test', 'list', '--format', '{sha256} {path}{NL}')
         assert "cdc76e5c9914fb9281a1c7e284d73e67f1809a48a497200e046d39ccc7112cd0 input/amb" in output
         assert "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855 input/empty_file" in output
 
     def test_list_consider_checkpoints(self):
-        self.cmd('init', '--encryption=repokey', self.repository_location)
-        self.cmd('create', self.repository_location + '::test1', src_dir)
+        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}::test1', 'create', src_dir)
         # these are not really a checkpoints, but they look like some:
-        self.cmd('create', self.repository_location + '::test2.checkpoint', src_dir)
-        self.cmd('create', self.repository_location + '::test3.checkpoint.1', src_dir)
-        output = self.cmd('list', self.repository_location)
+        self.cmd(f'--repo={self.repository_location}::test2.checkpoint', 'create', src_dir)
+        self.cmd(f'--repo={self.repository_location}::test3.checkpoint.1', 'create', src_dir)
+        output = self.cmd(f'--repo={self.repository_location}', 'list')
         assert "test1" in output
         assert "test2.checkpoint" not in output
         assert "test3.checkpoint.1" not in output
-        output = self.cmd('list', '--consider-checkpoints', self.repository_location)
+        output = self.cmd(f'--repo={self.repository_location}', 'list', '--consider-checkpoints')
         assert "test1" in output
         assert "test2.checkpoint" in output
         assert "test3.checkpoint.1" in output
@@ -2351,27 +2355,25 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         with open(os.path.join(self.input_path, 'two_chunks'), 'wb') as fd:
             fd.write(b'abba' * 2000000)
             fd.write(b'baab' * 2000000)
-        self.cmd('init', '--encryption=repokey', self.repository_location)
-        test_archive = self.repository_location + '::test'
-        self.cmd('create', test_archive, 'input')
-        output = self.cmd('list', '--format', '{num_chunks} {unique_chunks} {path}{NL}', test_archive)
+        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}::test', 'create', 'input')
+        output = self.cmd(f'--repo={self.repository_location}::test', 'list', '--format', '{num_chunks} {unique_chunks} {path}{NL}')
         assert "0 0 input/empty_file" in output
         assert "2 2 input/two_chunks" in output
 
     def test_list_size(self):
         self.create_regular_file('compressible_file', size=10000)
-        self.cmd('init', '--encryption=repokey', self.repository_location)
-        test_archive = self.repository_location + '::test'
-        self.cmd('create', '-C', 'lz4', test_archive, 'input')
-        output = self.cmd('list', '--format', '{size} {path}{NL}', test_archive)
+        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}::test', 'create', '-C', 'lz4', 'input')
+        output = self.cmd(f'--repo={self.repository_location}::test', 'list', '--format', '{size} {path}{NL}')
         size, path = output.split("\n")[1].split(" ")
         assert int(size) == 10000
 
     def test_list_json(self):
         self.create_regular_file('file1', size=1024 * 80)
-        self.cmd('init', '--encryption=repokey', self.repository_location)
-        self.cmd('create', self.repository_location + '::test', 'input')
-        list_repo = json.loads(self.cmd('list', '--json', self.repository_location))
+        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}::test', 'create', 'input')
+        list_repo = json.loads(self.cmd(f'--repo={self.repository_location}', 'list', '--json'))
         repository = list_repo['repository']
         assert len(repository['id']) == 64
         assert datetime.strptime(repository['last_modified'], ISO_FORMAT)  # must not raise
@@ -2380,7 +2382,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         archive0 = list_repo['archives'][0]
         assert datetime.strptime(archive0['time'], ISO_FORMAT)  # must not raise
 
-        list_archive = self.cmd('list', '--json-lines', self.repository_location + '::test')
+        list_archive = self.cmd(f'--repo={self.repository_location}::test', 'list', '--json-lines')
         items = [json.loads(s) for s in list_archive.splitlines()]
         assert len(items) == 2
         file1 = items[1]
@@ -2388,7 +2390,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         assert file1['size'] == 81920
         assert datetime.strptime(file1['mtime'], ISO_FORMAT)  # must not raise
 
-        list_archive = self.cmd('list', '--json-lines', '--format={sha256}', self.repository_location + '::test')
+        list_archive = self.cmd(f'--repo={self.repository_location}::test', 'list', '--json-lines', '--format={sha256}')
         items = [json.loads(s) for s in list_archive.splitlines()]
         assert len(items) == 2
         file1 = items[1]
@@ -2396,14 +2398,14 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         assert file1['sha256'] == 'b2915eb69f260d8d3c25249195f2c8f4f716ea82ec760ae929732c0262442b2b'
 
     def test_list_json_args(self):
-        self.cmd('init', '--encryption=repokey', self.repository_location)
-        self.cmd('list', '--json-lines', self.repository_location, exit_code=2)
-        self.cmd('list', '--json', self.repository_location + '::archive', exit_code=2)
+        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'list', '--json-lines', exit_code=2)
+        self.cmd(f'--repo={self.repository_location}::archive', 'list', '--json', exit_code=2)
 
     def test_log_json(self):
         self.create_test_files()
-        self.cmd('init', '--encryption=repokey', self.repository_location)
-        log = self.cmd('create', '--log-json', self.repository_location + '::test', 'input', '--list', '--debug')
+        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        log = self.cmd(f'--repo={self.repository_location}::test', 'create', '--log-json', 'input', '--list', '--debug')
         messages = {}  # type -> message, one of each kind
         for line in log.splitlines():
             msg = json.loads(line)
@@ -2420,67 +2422,67 @@ class ArchiverTestCase(ArchiverTestCaseBase):
 
     def test_debug_profile(self):
         self.create_test_files()
-        self.cmd('init', '--encryption=repokey', self.repository_location)
-        self.cmd('create', self.repository_location + '::test', 'input', '--debug-profile=create.prof')
+        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}::test', 'create', 'input', '--debug-profile=create.prof')
         self.cmd('debug', 'convert-profile', 'create.prof', 'create.pyprof')
         stats = pstats.Stats('create.pyprof')
         stats.strip_dirs()
         stats.sort_stats('cumtime')
 
-        self.cmd('create', self.repository_location + '::test2', 'input', '--debug-profile=create.pyprof')
+        self.cmd(f'--repo={self.repository_location}::test2', 'create', 'input', '--debug-profile=create.pyprof')
         stats = pstats.Stats('create.pyprof')  # Only do this on trusted data!
         stats.strip_dirs()
         stats.sort_stats('cumtime')
 
     def test_common_options(self):
         self.create_test_files()
-        self.cmd('init', '--encryption=repokey', self.repository_location)
-        log = self.cmd('--debug', 'create', self.repository_location + '::test', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        log = self.cmd(f'--repo={self.repository_location}::test', '--debug', 'create', 'input')
         assert 'security: read previous location' in log
 
     def test_change_passphrase(self):
-        self.cmd('init', '--encryption=repokey', self.repository_location)
+        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
         os.environ['BORG_NEW_PASSPHRASE'] = 'newpassphrase'
         # here we have both BORG_PASSPHRASE and BORG_NEW_PASSPHRASE set:
-        self.cmd('key', 'change-passphrase', self.repository_location)
+        self.cmd(f'--repo={self.repository_location}', 'key', 'change-passphrase')
         os.environ['BORG_PASSPHRASE'] = 'newpassphrase'
-        self.cmd('list', self.repository_location)
+        self.cmd(f'--repo={self.repository_location}', 'list')
 
     def test_change_location_to_keyfile(self):
-        self.cmd('init', '--encryption=repokey', self.repository_location)
-        log = self.cmd('info', self.repository_location)
+        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        log = self.cmd(f'--repo={self.repository_location}', 'info')
         assert '(repokey)' in log
-        self.cmd('key', 'change-location', self.repository_location, 'keyfile')
-        log = self.cmd('info', self.repository_location)
+        self.cmd(f'--repo={self.repository_location}', 'key', 'change-location', 'keyfile')
+        log = self.cmd(f'--repo={self.repository_location}', 'info')
         assert '(key file)' in log
 
     def test_change_location_to_b2keyfile(self):
-        self.cmd('init', '--encryption=repokey-blake2', self.repository_location)
-        log = self.cmd('info', self.repository_location)
+        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey-blake2')
+        log = self.cmd(f'--repo={self.repository_location}', 'info')
         assert '(repokey BLAKE2b)' in log
-        self.cmd('key', 'change-location', self.repository_location, 'keyfile')
-        log = self.cmd('info', self.repository_location)
+        self.cmd(f'--repo={self.repository_location}', 'key', 'change-location', 'keyfile')
+        log = self.cmd(f'--repo={self.repository_location}', 'info')
         assert '(key file BLAKE2b)' in log
 
     def test_change_location_to_repokey(self):
-        self.cmd('init', '--encryption=keyfile', self.repository_location)
-        log = self.cmd('info', self.repository_location)
+        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=keyfile')
+        log = self.cmd(f'--repo={self.repository_location}', 'info')
         assert '(key file)' in log
-        self.cmd('key', 'change-location', self.repository_location, 'repokey')
-        log = self.cmd('info', self.repository_location)
+        self.cmd(f'--repo={self.repository_location}', 'key', 'change-location', 'repokey')
+        log = self.cmd(f'--repo={self.repository_location}', 'info')
         assert '(repokey)' in log
 
     def test_change_location_to_b2repokey(self):
-        self.cmd('init', '--encryption=keyfile-blake2', self.repository_location)
-        log = self.cmd('info', self.repository_location)
+        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=keyfile-blake2')
+        log = self.cmd(f'--repo={self.repository_location}', 'info')
         assert '(key file BLAKE2b)' in log
-        self.cmd('key', 'change-location', self.repository_location, 'repokey')
-        log = self.cmd('info', self.repository_location)
+        self.cmd(f'--repo={self.repository_location}', 'key', 'change-location', 'repokey')
+        log = self.cmd(f'--repo={self.repository_location}', 'info')
         assert '(repokey BLAKE2b)' in log
 
     def test_break_lock(self):
-        self.cmd('init', '--encryption=repokey', self.repository_location)
-        self.cmd('break-lock', self.repository_location)
+        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'break-lock')
 
     def test_usage(self):
         self.cmd()
@@ -2506,11 +2508,11 @@ class ArchiverTestCase(ArchiverTestCaseBase):
                 noatime_used = flags_noatime != flags_normal
                 return noatime_used and atime_before == atime_after
 
-        self.cmd('init', '--encryption=repokey', self.repository_location)
+        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
         self.create_test_files()
         have_noatime = has_noatime('input/file1')
-        self.cmd('create', '--exclude-nodump', '--atime', self.repository_location + '::archive', 'input')
-        self.cmd('create', '--exclude-nodump', '--atime', self.repository_location + '::archive2', 'input')
+        self.cmd(f'--repo={self.repository_location}::archive', 'create', '--exclude-nodump', '--atime', 'input')
+        self.cmd(f'--repo={self.repository_location}::archive2', 'create', '--exclude-nodump', '--atime', 'input')
         if has_lchflags:
             # remove the file we did not backup, so input and output become equal
             os.remove(os.path.join('input', 'flagfile'))
@@ -2596,15 +2598,15 @@ class ArchiverTestCase(ArchiverTestCaseBase):
 
     @unittest.skipUnless(llfuse, 'llfuse not installed')
     def test_fuse_versions_view(self):
-        self.cmd('init', '--encryption=repokey', self.repository_location)
+        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
         self.create_regular_file('test', contents=b'first')
         if are_hardlinks_supported():
             self.create_regular_file('hardlink1', contents=b'123456')
             os.link('input/hardlink1', 'input/hardlink2')
             os.link('input/hardlink1', 'input/hardlink3')
-        self.cmd('create', self.repository_location + '::archive1', 'input')
+        self.cmd(f'--repo={self.repository_location}::archive1', 'create', 'input')
         self.create_regular_file('test', contents=b'second')
-        self.cmd('create', self.repository_location + '::archive2', 'input')
+        self.cmd(f'--repo={self.repository_location}::archive2', 'create', 'input')
         mountpoint = os.path.join(self.tmpdir, 'mountpoint')
         # mount the whole repository, archive contents shall show up in versioned view:
         with self.fuse_mount(self.repository_location, mountpoint, '-o', 'versions'):
@@ -2628,7 +2630,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
 
     @unittest.skipUnless(llfuse, 'llfuse not installed')
     def test_fuse_allow_damaged_files(self):
-        self.cmd('init', '--encryption=repokey', self.repository_location)
+        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
         self.create_src_archive('archive')
         # Get rid of a chunk and repair it
         archive, repository = self.open_archive('archive')
@@ -2641,7 +2643,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
             else:
                 assert False  # missed the file
             repository.commit(compact=False)
-        self.cmd('check', '--repair', self.repository_location, exit_code=0)
+        self.cmd(f'--repo={self.repository_location}', 'check', '--repair', exit_code=0)
 
         mountpoint = os.path.join(self.tmpdir, 'mountpoint')
         with self.fuse_mount(self.repository_location + '::archive', mountpoint):
@@ -2653,7 +2655,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
 
     @unittest.skipUnless(llfuse, 'llfuse not installed')
     def test_fuse_mount_options(self):
-        self.cmd('init', '--encryption=repokey', self.repository_location)
+        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
         self.create_src_archive('arch11')
         self.create_src_archive('arch12')
         self.create_src_archive('arch21')
@@ -2727,7 +2729,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         # Decorate
         borg.locking.Lock.migrate_lock = write_assert_data(borg.locking.Lock.migrate_lock)
         try:
-            self.cmd('init', '--encryption=none', self.repository_location)
+            self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=none')
             self.create_src_archive('arch')
             mountpoint = os.path.join(self.tmpdir, 'mountpoint')
             # In order that the decoration is kept for the borg mount process, we must not spawn, but actually fork;
@@ -2780,13 +2782,13 @@ class ArchiverTestCase(ArchiverTestCaseBase):
 
         self.create_test_files()
         os.environ['BORG_PASSPHRASE'] = 'passphrase'
-        self.cmd('init', '--encryption=' + method, self.repository_location)
+        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=' + method)
         verify_uniqueness()
-        self.cmd('create', self.repository_location + '::test', 'input')
+        self.cmd(f'--repo={self.repository_location}::test', 'create', 'input')
         verify_uniqueness()
-        self.cmd('create', self.repository_location + '::test.2', 'input')
+        self.cmd(f'--repo={self.repository_location}::test.2', 'create', 'input')
         verify_uniqueness()
-        self.cmd('delete', self.repository_location + '::test.2')
+        self.cmd(f'--repo={self.repository_location}::test.2', 'delete')
         verify_uniqueness()
 
     def test_aes_counter_uniqueness_keyfile(self):
@@ -2797,41 +2799,41 @@ class ArchiverTestCase(ArchiverTestCaseBase):
 
     def test_debug_dump_archive_items(self):
         self.create_test_files()
-        self.cmd('init', '--encryption=repokey', self.repository_location)
-        self.cmd('create', self.repository_location + '::test', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}::test', 'create', 'input')
         with changedir('output'):
-            output = self.cmd('debug', 'dump-archive-items', self.repository_location + '::test')
+            output = self.cmd(f'--repo={self.repository_location}::test', 'debug', 'dump-archive-items')
         output_dir = sorted(os.listdir('output'))
         assert len(output_dir) > 0 and output_dir[0].startswith('000000_')
         assert 'Done.' in output
 
     def test_debug_dump_repo_objs(self):
         self.create_test_files()
-        self.cmd('init', '--encryption=repokey', self.repository_location)
-        self.cmd('create', self.repository_location + '::test', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}::test', 'create', 'input')
         with changedir('output'):
-            output = self.cmd('debug', 'dump-repo-objs', self.repository_location)
+            output = self.cmd(f'--repo={self.repository_location}', 'debug', 'dump-repo-objs')
         output_dir = sorted(os.listdir('output'))
         assert len(output_dir) > 0 and output_dir[0].startswith('00000000_')
         assert 'Done.' in output
 
     def test_debug_put_get_delete_obj(self):
-        self.cmd('init', '--encryption=repokey', self.repository_location)
+        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
         data = b'some data'
         hexkey = sha256(data).hexdigest()
         self.create_regular_file('file', contents=data)
-        output = self.cmd('debug', 'put-obj', self.repository_location, 'input/file')
+        output = self.cmd(f'--repo={self.repository_location}', 'debug', 'put-obj', 'input/file')
         assert hexkey in output
-        output = self.cmd('debug', 'get-obj', self.repository_location, hexkey, 'output/file')
+        output = self.cmd(f'--repo={self.repository_location}', 'debug', 'get-obj', hexkey, 'output/file')
         assert hexkey in output
         with open('output/file', 'rb') as f:
             data_read = f.read()
         assert data == data_read
-        output = self.cmd('debug', 'delete-obj', self.repository_location, hexkey)
+        output = self.cmd(f'--repo={self.repository_location}', 'debug', 'delete-obj', hexkey)
         assert "deleted" in output
-        output = self.cmd('debug', 'delete-obj', self.repository_location, hexkey)
+        output = self.cmd(f'--repo={self.repository_location}', 'debug', 'delete-obj', hexkey)
         assert "not found" in output
-        output = self.cmd('debug', 'delete-obj', self.repository_location, 'invalid')
+        output = self.cmd(f'--repo={self.repository_location}', 'debug', 'delete-obj', 'invalid')
         assert "is invalid" in output
 
     def test_init_interrupt(self):
@@ -2839,19 +2841,19 @@ class ArchiverTestCase(ArchiverTestCaseBase):
             raise EOFError
 
         with patch.object(FlexiKey, 'create', raise_eof):
-            self.cmd('init', '--encryption=repokey', self.repository_location, exit_code=1)
+            self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey', exit_code=1)
         assert not os.path.exists(self.repository_location)
 
     def test_init_requires_encryption_option(self):
-        self.cmd('init', self.repository_location, exit_code=2)
+        self.cmd(f'--repo={self.repository_location}', 'init', exit_code=2)
 
     def test_init_nested_repositories(self):
-        self.cmd('init', '--encryption=repokey', self.repository_location)
+        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
         if self.FORK_DEFAULT:
-            self.cmd('init', '--encryption=repokey', self.repository_location + '/nested', exit_code=2)
+            self.cmd(f'--repo={self.repository_location}/nested', 'init', '--encryption=repokey', exit_code=2)
         else:
             with pytest.raises(Repository.AlreadyExists):
-                self.cmd('init', '--encryption=repokey', self.repository_location + '/nested')
+                self.cmd(f'--repo={self.repository_location}/nested', 'init', '--encryption=repokey')
 
     def test_init_refuse_to_overwrite_keyfile(self):
         """BORG_KEY_FILE=something borg init should quit if "something" already exists.
@@ -2859,10 +2861,10 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         See https://github.com/borgbackup/borg/pull/6046"""
         keyfile = os.path.join(self.tmpdir, 'keyfile')
         with environment_variable(BORG_KEY_FILE=keyfile):
-            self.cmd('init', '--encryption=keyfile', self.repository_location + '0')
+            self.cmd(f'--repo={self.repository_location}0', 'init', '--encryption=keyfile')
             with open(keyfile) as file:
                 before = file.read()
-            arg = ('init', '--encryption=keyfile', self.repository_location + '1')
+            arg = (f'--repo={self.repository_location}1', 'init', '--encryption=keyfile')
             if self.FORK_DEFAULT:
                 self.cmd(*arg, exit_code=2)
             else:
@@ -2874,7 +2876,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
 
     def check_cache(self):
         # First run a regular borg check
-        self.cmd('check', self.repository_location)
+        self.cmd(f'--repo={self.repository_location}', 'check')
         # Then check that the cache on disk matches exactly what's in the repo.
         with self.open_repository() as repository:
             manifest, key = Manifest.load(repository, Manifest.NO_OPERATION_CHECK)
@@ -2894,8 +2896,8 @@ class ArchiverTestCase(ArchiverTestCaseBase):
             assert id in seen
 
     def test_check_cache(self):
-        self.cmd('init', '--encryption=repokey', self.repository_location)
-        self.cmd('create', self.repository_location + '::test', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}::test', 'create', 'input')
         with self.open_repository() as repository:
             manifest, key = Manifest.load(repository, Manifest.NO_OPERATION_CHECK)
             with Cache(repository, key, manifest, sync=False) as cache:
@@ -2906,26 +2908,25 @@ class ArchiverTestCase(ArchiverTestCaseBase):
             self.check_cache()
 
     def test_recreate_target_rc(self):
-        self.cmd('init', '--encryption=repokey', self.repository_location)
-        output = self.cmd('recreate', self.repository_location, '--target=asdf', exit_code=2)
+        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        output = self.cmd(f'--repo={self.repository_location}', 'recreate', '--target=asdf', exit_code=2)
         assert 'Need to specify single archive' in output
 
     def test_recreate_target(self):
         self.create_test_files()
-        self.cmd('init', '--encryption=repokey', self.repository_location)
+        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
         self.check_cache()
-        archive = self.repository_location + '::test0'
-        self.cmd('create', archive, 'input')
+        self.cmd(f'--repo={self.repository_location}::test0', 'create', 'input')
         self.check_cache()
-        original_archive = self.cmd('list', self.repository_location)
-        self.cmd('recreate', archive, 'input/dir2', '-e', 'input/dir2/file3', '--target=new-archive')
+        original_archive = self.cmd(f'--repo={self.repository_location}', 'list')
+        self.cmd(f'--repo={self.repository_location}::test0', 'recreate', 'input/dir2',
+                 '-e', 'input/dir2/file3', '--target=new-archive')
         self.check_cache()
-        archives = self.cmd('list', self.repository_location)
+        archives = self.cmd(f'--repo={self.repository_location}', 'list')
         assert original_archive in archives
         assert 'new-archive' in archives
 
-        archive = self.repository_location + '::new-archive'
-        listing = self.cmd('list', '--short', archive)
+        listing = self.cmd(f'--repo={self.repository_location}::new-archive', 'list', '--short')
         assert 'file1' not in listing
         assert 'dir2/file2' in listing
         assert 'dir2/file3' not in listing
@@ -2933,12 +2934,11 @@ class ArchiverTestCase(ArchiverTestCaseBase):
     def test_recreate_basic(self):
         self.create_test_files()
         self.create_regular_file('dir2/file3', size=1024 * 80)
-        self.cmd('init', '--encryption=repokey', self.repository_location)
-        archive = self.repository_location + '::test0'
-        self.cmd('create', archive, 'input')
-        self.cmd('recreate', archive, 'input/dir2', '-e', 'input/dir2/file3')
+        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}::test0', 'create', 'input')
+        self.cmd(f'--repo={self.repository_location}::test0', 'recreate', 'input/dir2', '-e', 'input/dir2/file3')
         self.check_cache()
-        listing = self.cmd('list', '--short', archive)
+        listing = self.cmd(f'--repo={self.repository_location}::test0', 'list', '--short')
         assert 'file1' not in listing
         assert 'dir2/file2' in listing
         assert 'dir2/file3' not in listing
@@ -2947,48 +2947,48 @@ class ArchiverTestCase(ArchiverTestCaseBase):
     def test_recreate_subtree_hardlinks(self):
         # This is essentially the same problem set as in test_extract_hardlinks
         self._extract_hardlinks_setup()
-        self.cmd('create', self.repository_location + '::test2', 'input')
-        self.cmd('recreate', self.repository_location + '::test', 'input/dir1')
+        self.cmd(f'--repo={self.repository_location}::test2', 'create', 'input')
+        self.cmd(f'--repo={self.repository_location}::test', 'recreate', 'input/dir1')
         self.check_cache()
         with changedir('output'):
-            self.cmd('extract', self.repository_location + '::test')
+            self.cmd(f'--repo={self.repository_location}::test', 'extract')
             assert os.stat('input/dir1/hardlink').st_nlink == 2
             assert os.stat('input/dir1/subdir/hardlink').st_nlink == 2
             assert os.stat('input/dir1/aaaa').st_nlink == 2
             assert os.stat('input/dir1/source2').st_nlink == 2
         with changedir('output'):
-            self.cmd('extract', self.repository_location + '::test2')
+            self.cmd(f'--repo={self.repository_location}::test2', 'extract')
             assert os.stat('input/dir1/hardlink').st_nlink == 4
 
     def test_recreate_rechunkify(self):
         with open(os.path.join(self.input_path, 'large_file'), 'wb') as fd:
             fd.write(b'a' * 280)
             fd.write(b'b' * 280)
-        self.cmd('init', '--encryption=repokey', self.repository_location)
-        self.cmd('create', '--chunker-params', '7,9,8,128', self.repository_location + '::test1', 'input')
-        self.cmd('create', self.repository_location + '::test2', 'input', '--files-cache=disabled')
-        list = self.cmd('list', self.repository_location + '::test1', 'input/large_file',
+        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}::test1', 'create', '--chunker-params', '7,9,8,128', 'input')
+        self.cmd(f'--repo={self.repository_location}::test2', 'create', 'input', '--files-cache=disabled')
+        list = self.cmd(f'--repo={self.repository_location}::test1', 'list', 'input/large_file',
                         '--format', '{num_chunks} {unique_chunks}')
         num_chunks, unique_chunks = map(int, list.split(' '))
         # test1 and test2 do not deduplicate
         assert num_chunks == unique_chunks
-        self.cmd('recreate', self.repository_location, '--chunker-params', 'default')
+        self.cmd(f'--repo={self.repository_location}', 'recreate', '--chunker-params', 'default')
         self.check_cache()
         # test1 and test2 do deduplicate after recreate
-        assert int(self.cmd('list', self.repository_location + '::test1', 'input/large_file', '--format={size}'))
-        assert not int(self.cmd('list', self.repository_location + '::test1', 'input/large_file',
+        assert int(self.cmd(f'--repo={self.repository_location}::test1', 'list', 'input/large_file', '--format={size}'))
+        assert not int(self.cmd(f'--repo={self.repository_location}::test1', 'list', 'input/large_file',
                                 '--format', '{unique_chunks}'))
 
     def test_recreate_recompress(self):
         self.create_regular_file('compressible', size=10000)
-        self.cmd('init', '--encryption=repokey', self.repository_location)
-        self.cmd('create', self.repository_location + '::test', 'input', '-C', 'none')
-        file_list = self.cmd('list', self.repository_location + '::test', 'input/compressible',
+        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}::test', 'create', 'input', '-C', 'none')
+        file_list = self.cmd(f'--repo={self.repository_location}::test', 'list', 'input/compressible',
                              '--format', '{size} {sha256}')
         size, sha256_before = file_list.split(' ')
-        self.cmd('recreate', self.repository_location, '-C', 'lz4', '--recompress')
+        self.cmd(f'--repo={self.repository_location}', 'recreate', '-C', 'lz4', '--recompress')
         self.check_cache()
-        file_list = self.cmd('list', self.repository_location + '::test', 'input/compressible',
+        file_list = self.cmd(f'--repo={self.repository_location}::test', 'list', 'input/compressible',
                              '--format', '{size} {sha256}')
         size, sha256_after = file_list.split(' ')
         assert sha256_before == sha256_after
@@ -2996,12 +2996,11 @@ class ArchiverTestCase(ArchiverTestCaseBase):
     def test_recreate_timestamp(self):
         local_timezone = datetime.now(timezone(timedelta(0))).astimezone().tzinfo
         self.create_test_files()
-        self.cmd('init', '--encryption=repokey', self.repository_location)
-        archive = self.repository_location + '::test0'
-        self.cmd('create', archive, 'input')
-        self.cmd('recreate', '--timestamp', "1970-01-02T00:00:00", '--comment',
-                 'test', archive)
-        info = self.cmd('info', archive).splitlines()
+        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}::test0', 'create', 'input')
+        self.cmd(f'--repo={self.repository_location}::test0', 'recreate', '--timestamp', "1970-01-02T00:00:00",
+                 '--comment', 'test')
+        info = self.cmd(f'--repo={self.repository_location}::test0', 'info').splitlines()
         dtime = datetime(1970, 1, 2) + local_timezone.utcoffset(None)
         s_time = dtime.strftime("%Y-%m-%d")
         assert any([re.search(r'Time \(start\).+ %s' % s_time, item) for item in info])
@@ -3009,70 +3008,70 @@ class ArchiverTestCase(ArchiverTestCaseBase):
 
     def test_recreate_dry_run(self):
         self.create_regular_file('compressible', size=10000)
-        self.cmd('init', '--encryption=repokey', self.repository_location)
-        self.cmd('create', self.repository_location + '::test', 'input')
-        archives_before = self.cmd('list', self.repository_location + '::test')
-        self.cmd('recreate', self.repository_location, '-n', '-e', 'input/compressible')
+        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}::test', 'create', 'input')
+        archives_before = self.cmd(f'--repo={self.repository_location}::test', 'list')
+        self.cmd(f'--repo={self.repository_location}', 'recreate', '-n', '-e', 'input/compressible')
         self.check_cache()
-        archives_after = self.cmd('list', self.repository_location + '::test')
+        archives_after = self.cmd(f'--repo={self.repository_location}::test', 'list')
         assert archives_after == archives_before
 
     def test_recreate_skips_nothing_to_do(self):
         self.create_regular_file('file1', size=1024 * 80)
-        self.cmd('init', '--encryption=repokey', self.repository_location)
-        self.cmd('create', self.repository_location + '::test', 'input')
-        info_before = self.cmd('info', self.repository_location + '::test')
-        self.cmd('recreate', self.repository_location, '--chunker-params', 'default')
+        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}::test', 'create', 'input')
+        info_before = self.cmd(f'--repo={self.repository_location}::test', 'info')
+        self.cmd(f'--repo={self.repository_location}', 'recreate', '--chunker-params', 'default')
         self.check_cache()
-        info_after = self.cmd('info', self.repository_location + '::test')
+        info_after = self.cmd(f'--repo={self.repository_location}::test', 'info')
         assert info_before == info_after  # includes archive ID
 
     def test_with_lock(self):
-        self.cmd('init', '--encryption=repokey', self.repository_location)
+        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
         lock_path = os.path.join(self.repository_path, 'lock.exclusive')
         cmd = 'python3', '-c', 'import os, sys; sys.exit(42 if os.path.exists("%s") else 23)' % lock_path
-        self.cmd('with-lock', self.repository_location, *cmd, fork=True, exit_code=42)
+        self.cmd(f'--repo={self.repository_location}', 'with-lock', *cmd, fork=True, exit_code=42)
 
     def test_recreate_list_output(self):
-        self.cmd('init', '--encryption=repokey', self.repository_location)
+        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
         self.create_regular_file('file1', size=0)
         self.create_regular_file('file2', size=0)
         self.create_regular_file('file3', size=0)
         self.create_regular_file('file4', size=0)
         self.create_regular_file('file5', size=0)
 
-        self.cmd('create', self.repository_location + '::test', 'input')
+        self.cmd(f'--repo={self.repository_location}::test', 'create', 'input')
 
-        output = self.cmd('recreate', '--list', '--info', self.repository_location + '::test', '-e', 'input/file2')
+        output = self.cmd(f'--repo={self.repository_location}::test', 'recreate', '--list', '--info', '-e', 'input/file2')
         self.check_cache()
         self.assert_in("input/file1", output)
         self.assert_in("x input/file2", output)
 
-        output = self.cmd('recreate', '--list', self.repository_location + '::test', '-e', 'input/file3')
+        output = self.cmd(f'--repo={self.repository_location}::test', 'recreate', '--list', '-e', 'input/file3')
         self.check_cache()
         self.assert_in("input/file1", output)
         self.assert_in("x input/file3", output)
 
-        output = self.cmd('recreate', self.repository_location + '::test', '-e', 'input/file4')
+        output = self.cmd(f'--repo={self.repository_location}::test', 'recreate', '-e', 'input/file4')
         self.check_cache()
         self.assert_not_in("input/file1", output)
         self.assert_not_in("x input/file4", output)
 
-        output = self.cmd('recreate', '--info', self.repository_location + '::test', '-e', 'input/file5')
+        output = self.cmd(f'--repo={self.repository_location}::test', 'recreate', '--info', '-e', 'input/file5')
         self.check_cache()
         self.assert_not_in("input/file1", output)
         self.assert_not_in("x input/file5", output)
 
     def test_bad_filters(self):
-        self.cmd('init', '--encryption=repokey', self.repository_location)
-        self.cmd('create', self.repository_location + '::test', 'input')
-        self.cmd('delete', '--first', '1', '--last', '1', self.repository_location, fork=True, exit_code=2)
+        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}::test', 'create', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'delete', '--first', '1', '--last', '1', fork=True, exit_code=2)
 
     def test_key_export_keyfile(self):
         export_file = self.output_path + '/exported'
-        self.cmd('init', self.repository_location, '--encryption', 'keyfile')
+        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption', 'keyfile')
         repo_id = self._extract_repository_id(self.repository_path)
-        self.cmd('key', 'export', self.repository_location, export_file)
+        self.cmd(f'--repo={self.repository_location}', 'key', 'export', export_file)
 
         with open(export_file) as fd:
             export_contents = fd.read()
@@ -3088,7 +3087,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
 
         os.unlink(key_file)
 
-        self.cmd('key', 'import', self.repository_location, export_file)
+        self.cmd(f'--repo={self.repository_location}', 'key', 'import', export_file)
 
         with open(key_file) as fd:
             key_contents2 = fd.read()
@@ -3096,10 +3095,10 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         assert key_contents2 == key_contents
 
     def test_key_import_keyfile_with_borg_key_file(self):
-        self.cmd('init', self.repository_location, '--encryption', 'keyfile')
+        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption', 'keyfile')
 
         exported_key_file = os.path.join(self.output_path, 'exported')
-        self.cmd('key', 'export', self.repository_location, exported_key_file)
+        self.cmd(f'--repo={self.repository_location}', 'key', 'export', exported_key_file)
 
         key_file = os.path.join(self.keys_path, os.listdir(self.keys_path)[0])
         with open(key_file) as fd:
@@ -3108,7 +3107,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
 
         imported_key_file = os.path.join(self.output_path, 'imported')
         with environment_variable(BORG_KEY_FILE=imported_key_file):
-            self.cmd('key', 'import', self.repository_location, exported_key_file)
+            self.cmd(f'--repo={self.repository_location}', 'key', 'import', exported_key_file)
         assert not os.path.isfile(key_file), '"borg key import" should respect BORG_KEY_FILE'
 
         with open(imported_key_file) as fd:
@@ -3117,9 +3116,9 @@ class ArchiverTestCase(ArchiverTestCaseBase):
 
     def test_key_export_repokey(self):
         export_file = self.output_path + '/exported'
-        self.cmd('init', self.repository_location, '--encryption', 'repokey')
+        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption', 'repokey')
         repo_id = self._extract_repository_id(self.repository_path)
-        self.cmd('key', 'export', self.repository_location, export_file)
+        self.cmd(f'--repo={self.repository_location}', 'key', 'export', export_file)
 
         with open(export_file) as fd:
             export_contents = fd.read()
@@ -3138,7 +3137,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         with Repository(self.repository_path) as repository:
             repository.save_key(b'')
 
-        self.cmd('key', 'import', self.repository_location, export_file)
+        self.cmd(f'--repo={self.repository_location}', 'key', 'import', export_file)
 
         with Repository(self.repository_path) as repository:
             repo_key2 = RepoKey(repository)
@@ -3148,9 +3147,9 @@ class ArchiverTestCase(ArchiverTestCaseBase):
 
     def test_key_export_qr(self):
         export_file = self.output_path + '/exported.html'
-        self.cmd('init', self.repository_location, '--encryption', 'repokey')
+        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption', 'repokey')
         repo_id = self._extract_repository_id(self.repository_path)
-        self.cmd('key', 'export', '--qr-html', self.repository_location, export_file)
+        self.cmd(f'--repo={self.repository_location}', 'key', 'export', '--qr-html', export_file)
 
         with open(export_file, encoding='utf-8') as fd:
             export_contents = fd.read()
@@ -3163,39 +3162,39 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         export_directory = self.output_path + '/exported'
         os.mkdir(export_directory)
 
-        self.cmd('init', self.repository_location, '--encryption', 'repokey')
+        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption', 'repokey')
 
-        self.cmd('key', 'export', self.repository_location, export_directory, exit_code=EXIT_ERROR)
+        self.cmd(f'--repo={self.repository_location}', 'key', 'export', export_directory, exit_code=EXIT_ERROR)
 
     def test_key_import_errors(self):
         export_file = self.output_path + '/exported'
-        self.cmd('init', self.repository_location, '--encryption', 'keyfile')
+        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption', 'keyfile')
 
-        self.cmd('key', 'import', self.repository_location, export_file, exit_code=EXIT_ERROR)
+        self.cmd(f'--repo={self.repository_location}', 'key', 'import', export_file, exit_code=EXIT_ERROR)
 
         with open(export_file, 'w') as fd:
             fd.write('something not a key\n')
 
         if self.FORK_DEFAULT:
-            self.cmd('key', 'import', self.repository_location, export_file, exit_code=2)
+            self.cmd(f'--repo={self.repository_location}', 'key', 'import', export_file, exit_code=2)
         else:
             with pytest.raises(NotABorgKeyFile):
-                self.cmd('key', 'import', self.repository_location, export_file)
+                self.cmd(f'--repo={self.repository_location}', 'key', 'import', export_file)
 
         with open(export_file, 'w') as fd:
             fd.write('BORG_KEY a0a0a0\n')
 
         if self.FORK_DEFAULT:
-            self.cmd('key', 'import', self.repository_location, export_file, exit_code=2)
+            self.cmd(f'--repo={self.repository_location}', 'key', 'import', export_file, exit_code=2)
         else:
             with pytest.raises(RepoIdMismatch):
-                self.cmd('key', 'import', self.repository_location, export_file)
+                self.cmd(f'--repo={self.repository_location}', 'key', 'import', export_file)
 
     def test_key_export_paperkey(self):
         repo_id = 'e294423506da4e1ea76e8dcdf1a3919624ae3ae496fddf905610c351d3f09239'
 
         export_file = self.output_path + '/exported'
-        self.cmd('init', self.repository_location, '--encryption', 'keyfile')
+        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption', 'keyfile')
         self._set_repository_id(self.repository_path, unhexlify(repo_id))
 
         key_file = self.keys_path + '/' + os.listdir(self.keys_path)[0]
@@ -3204,7 +3203,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
             fd.write(KeyfileKey.FILE_ID + ' ' + repo_id + '\n')
             fd.write(b2a_base64(b'abcdefghijklmnopqrstu').decode())
 
-        self.cmd('key', 'export', '--paper', self.repository_location, export_file)
+        self.cmd(f'--repo={self.repository_location}', 'key', 'export', '--paper', export_file)
 
         with open(export_file) as fd:
             export_contents = fd.read()
@@ -3219,7 +3218,7 @@ id: 2 / e29442 3506da 4e1ea7 / 25f62a 5a3d41 - 02
 
     def test_key_import_paperkey(self):
         repo_id = 'e294423506da4e1ea76e8dcdf1a3919624ae3ae496fddf905610c351d3f09239'
-        self.cmd('init', self.repository_location, '--encryption', 'keyfile')
+        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption', 'keyfile')
         self._set_repository_id(self.repository_path, unhexlify(repo_id))
 
         key_file = self.keys_path + '/' + os.listdir(self.keys_path)[0]
@@ -3254,20 +3253,20 @@ id: 2 / e29442 3506da 4e1ea7 / 25f62a 5a3d41 - 02
         #         print(i.to_bytes(2, 'big'))
         #         break
 
-        self.cmd('key', 'import', '--paper', self.repository_location, input=typed_input)
+        self.cmd(f'--repo={self.repository_location}', 'key', 'import', '--paper', input=typed_input)
 
         # Test abort paths
         typed_input = b'\ny\n'
-        self.cmd('key', 'import', '--paper', self.repository_location, input=typed_input)
+        self.cmd(f'--repo={self.repository_location}', 'key', 'import', '--paper', input=typed_input)
         typed_input = b'2 / e29442 3506da 4e1ea7 / 25f62a 5a3d41 - 02\n\ny\n'
-        self.cmd('key', 'import', '--paper', self.repository_location, input=typed_input)
+        self.cmd(f'--repo={self.repository_location}', 'key', 'import', '--paper', input=typed_input)
 
     def test_debug_dump_manifest(self):
         self.create_regular_file('file1', size=1024 * 80)
-        self.cmd('init', '--encryption=repokey', self.repository_location)
-        self.cmd('create', self.repository_location + '::test', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}::test', 'create', 'input')
         dump_file = self.output_path + '/dump'
-        output = self.cmd('debug', 'dump-manifest', self.repository_location, dump_file)
+        output = self.cmd(f'--repo={self.repository_location}', 'debug', 'dump-manifest', dump_file)
         assert output == ""
         with open(dump_file) as f:
             result = json.load(f)
@@ -3279,10 +3278,10 @@ id: 2 / e29442 3506da 4e1ea7 / 25f62a 5a3d41 - 02
 
     def test_debug_dump_archive(self):
         self.create_regular_file('file1', size=1024 * 80)
-        self.cmd('init', '--encryption=repokey', self.repository_location)
-        self.cmd('create', self.repository_location + '::test', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}::test', 'create', 'input')
         dump_file = self.output_path + '/dump'
-        output = self.cmd('debug', 'dump-archive', self.repository_location + "::test", dump_file)
+        output = self.cmd(f'--repo={self.repository_location}::test', 'debug', 'dump-archive', dump_file)
         assert output == ""
         with open(dump_file) as f:
             result = json.load(f)
@@ -3292,17 +3291,17 @@ id: 2 / e29442 3506da 4e1ea7 / 25f62a 5a3d41 - 02
         assert '_items' in result
 
     def test_debug_refcount_obj(self):
-        self.cmd('init', '--encryption=repokey', self.repository_location)
-        output = self.cmd('debug', 'refcount-obj', self.repository_location, '0' * 64).strip()
+        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        output = self.cmd(f'--repo={self.repository_location}', 'debug', 'refcount-obj', '0' * 64).strip()
         assert output == 'object 0000000000000000000000000000000000000000000000000000000000000000 not found [info from chunks cache].'
 
-        create_json = json.loads(self.cmd('create', '--json', self.repository_location + '::test', 'input'))
+        create_json = json.loads(self.cmd(f'--repo={self.repository_location}::test', 'create', '--json', 'input'))
         archive_id = create_json['archive']['id']
-        output = self.cmd('debug', 'refcount-obj', self.repository_location, archive_id).strip()
+        output = self.cmd(f'--repo={self.repository_location}', 'debug', 'refcount-obj', archive_id).strip()
         assert output == 'object ' + archive_id + ' has 1 referrers [info from chunks cache].'
 
         # Invalid IDs do not abort or return an error
-        output = self.cmd('debug', 'refcount-obj', self.repository_location, '124', 'xyza').strip()
+        output = self.cmd(f'--repo={self.repository_location}', 'debug', 'refcount-obj', '124', 'xyza').strip()
         assert output == 'object id 124 is invalid.\nobject id xyza is invalid.'
 
     def test_debug_info(self):
@@ -3311,15 +3310,15 @@ id: 2 / e29442 3506da 4e1ea7 / 25f62a 5a3d41 - 02
         assert 'Python' in output
 
     def test_benchmark_crud(self):
-        self.cmd('init', '--encryption=repokey', self.repository_location)
+        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
         with environment_variable(_BORG_BENCHMARK_CRUD_TEST='YES'):
-            self.cmd('benchmark', 'crud', self.repository_location, self.input_path)
+            self.cmd(f'--repo={self.repository_location}', 'benchmark', 'crud', self.input_path)
 
     def test_config(self):
         self.create_test_files()
         os.unlink('input/flagfile')
-        self.cmd('init', '--encryption=repokey', self.repository_location)
-        output = self.cmd('config', '--list', self.repository_location)
+        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        output = self.cmd(f'--repo={self.repository_location}', 'config', '--list')
         self.assert_in('[repository]', output)
         self.assert_in('version', output)
         self.assert_in('segments_per_dir', output)
@@ -3329,30 +3328,30 @@ id: 2 / e29442 3506da 4e1ea7 / 25f62a 5a3d41 - 02
         self.assert_in('id', output)
         self.assert_not_in('last_segment_checked', output)
 
-        output = self.cmd('config', self.repository_location, 'last_segment_checked', exit_code=1)
+        output = self.cmd(f'--repo={self.repository_location}', 'config', 'last_segment_checked', exit_code=1)
         self.assert_in('No option ', output)
-        self.cmd('config', self.repository_location, 'last_segment_checked', '123')
-        output = self.cmd('config', self.repository_location, 'last_segment_checked')
+        self.cmd(f'--repo={self.repository_location}', 'config', 'last_segment_checked', '123')
+        output = self.cmd(f'--repo={self.repository_location}', 'config', 'last_segment_checked')
         assert output == '123' + '\n'
-        output = self.cmd('config', '--list', self.repository_location)
+        output = self.cmd(f'--repo={self.repository_location}', 'config', '--list')
         self.assert_in('last_segment_checked', output)
-        self.cmd('config', '--delete', self.repository_location, 'last_segment_checked')
+        self.cmd(f'--repo={self.repository_location}', 'config', '--delete', 'last_segment_checked')
 
         for cfg_key, cfg_value in [
             ('additional_free_space', '2G'),
             ('repository.append_only', '1'),
         ]:
-            output = self.cmd('config', self.repository_location, cfg_key)
+            output = self.cmd(f'--repo={self.repository_location}', 'config', cfg_key)
             assert output == '0' + '\n'
-            self.cmd('config', self.repository_location, cfg_key, cfg_value)
-            output = self.cmd('config', self.repository_location, cfg_key)
+            self.cmd(f'--repo={self.repository_location}', 'config', cfg_key, cfg_value)
+            output = self.cmd(f'--repo={self.repository_location}', 'config', cfg_key)
             assert output == cfg_value + '\n'
-            self.cmd('config', '--delete', self.repository_location, cfg_key)
-            self.cmd('config', self.repository_location, cfg_key, exit_code=1)
+            self.cmd(f'--repo={self.repository_location}', 'config', '--delete', cfg_key)
+            self.cmd(f'--repo={self.repository_location}', 'config', cfg_key, exit_code=1)
 
-        self.cmd('config', '--list', '--delete', self.repository_location, exit_code=2)
-        self.cmd('config', self.repository_location, exit_code=2)
-        self.cmd('config', self.repository_location, 'invalid-option', exit_code=1)
+        self.cmd(f'--repo={self.repository_location}', 'config', '--list', '--delete', exit_code=2)
+        self.cmd(f'--repo={self.repository_location}', 'config', exit_code=2)
+        self.cmd(f'--repo={self.repository_location}', 'config', 'invalid-option', exit_code=1)
 
     requires_gnutar = pytest.mark.skipif(not have_gnutar(), reason='GNU tar must be installed for this test.')
     requires_gzip = pytest.mark.skipif(not shutil.which('gzip'), reason='gzip must be installed for this test.')
@@ -3361,9 +3360,9 @@ id: 2 / e29442 3506da 4e1ea7 / 25f62a 5a3d41 - 02
     def test_export_tar(self):
         self.create_test_files()
         os.unlink('input/flagfile')
-        self.cmd('init', '--encryption=repokey', self.repository_location)
-        self.cmd('create', self.repository_location + '::test', 'input')
-        self.cmd('export-tar', self.repository_location + '::test', 'simple.tar', '--progress', '--tar-format=GNU')
+        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}::test', 'create', 'input')
+        self.cmd(f'--repo={self.repository_location}::test', 'export-tar', 'simple.tar', '--progress', '--tar-format=GNU')
         with changedir('output'):
             # This probably assumes GNU tar. Note -p switch to extract permissions regardless of umask.
             subprocess.check_call(['tar', 'xpf', '../simple.tar', '--warning=no-timestamp'])
@@ -3376,9 +3375,9 @@ id: 2 / e29442 3506da 4e1ea7 / 25f62a 5a3d41 - 02
             pytest.skip('gzip is not installed')
         self.create_test_files()
         os.unlink('input/flagfile')
-        self.cmd('init', '--encryption=repokey', self.repository_location)
-        self.cmd('create', self.repository_location + '::test', 'input')
-        list = self.cmd('export-tar', self.repository_location + '::test', 'simple.tar.gz',
+        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}::test', 'create', 'input')
+        list = self.cmd(f'--repo={self.repository_location}::test', 'export-tar', 'simple.tar.gz',
                         '--list', '--tar-format=GNU')
         assert 'input/file1\n' in list
         assert 'input/dir2\n' in list
@@ -3392,9 +3391,9 @@ id: 2 / e29442 3506da 4e1ea7 / 25f62a 5a3d41 - 02
             pytest.skip('gzip is not installed')
         self.create_test_files()
         os.unlink('input/flagfile')
-        self.cmd('init', '--encryption=repokey', self.repository_location)
-        self.cmd('create', self.repository_location + '::test', 'input')
-        list = self.cmd('export-tar', self.repository_location + '::test', 'simple.tar',
+        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}::test', 'create', 'input')
+        list = self.cmd(f'--repo={self.repository_location}::test', 'export-tar', 'simple.tar',
                         '--strip-components=1', '--list', '--tar-format=GNU')
         # --list's path are those before processing with --strip-components
         assert 'input/file1\n' in list
@@ -3407,7 +3406,7 @@ id: 2 / e29442 3506da 4e1ea7 / 25f62a 5a3d41 - 02
     @requires_gnutar
     def test_export_tar_strip_components_links(self):
         self._extract_hardlinks_setup()
-        self.cmd('export-tar', self.repository_location + '::test', 'output.tar',
+        self.cmd(f'--repo={self.repository_location}::test', 'export-tar', 'output.tar',
                  '--strip-components=2', '--tar-format=GNU')
         with changedir('output'):
             subprocess.check_call(['tar', 'xpf', '../output.tar', '--warning=no-timestamp'])
@@ -3420,7 +3419,7 @@ id: 2 / e29442 3506da 4e1ea7 / 25f62a 5a3d41 - 02
     @requires_gnutar
     def test_extract_hardlinks_tar(self):
         self._extract_hardlinks_setup()
-        self.cmd('export-tar', self.repository_location + '::test', 'output.tar', 'input/dir1', '--tar-format=GNU')
+        self.cmd(f'--repo={self.repository_location}::test', 'export-tar', 'output.tar', 'input/dir1', '--tar-format=GNU')
         with changedir('output'):
             subprocess.check_call(['tar', 'xpf', '../output.tar', '--warning=no-timestamp'])
             assert os.stat('input/dir1/hardlink').st_nlink == 2
@@ -3431,12 +3430,12 @@ id: 2 / e29442 3506da 4e1ea7 / 25f62a 5a3d41 - 02
     def test_import_tar(self, tar_format='PAX'):
         self.create_test_files(create_hardlinks=False)  # hardlinks become separate files
         os.unlink('input/flagfile')
-        self.cmd('init', '--encryption=none', self.repository_location)
-        self.cmd('create', self.repository_location + '::src', 'input')
-        self.cmd('export-tar', self.repository_location + '::src', 'simple.tar', f'--tar-format={tar_format}')
-        self.cmd('import-tar', self.repository_location + '::dst', 'simple.tar')
+        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=none')
+        self.cmd(f'--repo={self.repository_location}::src', 'create', 'input')
+        self.cmd(f'--repo={self.repository_location}::src', 'export-tar', 'simple.tar', f'--tar-format={tar_format}')
+        self.cmd(f'--repo={self.repository_location}::dst', 'import-tar', 'simple.tar')
         with changedir(self.output_path):
-            self.cmd('extract', self.repository_location + '::dst')
+            self.cmd(f'--repo={self.repository_location}::dst', 'extract')
         self.assert_dirs_equal('input', 'output/input', ignore_ns=True, ignore_xattrs=True)
 
     @requires_gzip
@@ -3445,22 +3444,22 @@ id: 2 / e29442 3506da 4e1ea7 / 25f62a 5a3d41 - 02
             pytest.skip('gzip is not installed')
         self.create_test_files(create_hardlinks=False)  # hardlinks become separate files
         os.unlink('input/flagfile')
-        self.cmd('init', '--encryption=none', self.repository_location)
-        self.cmd('create', self.repository_location + '::src', 'input')
-        self.cmd('export-tar', self.repository_location + '::src', 'simple.tgz', f'--tar-format={tar_format}')
-        self.cmd('import-tar', self.repository_location + '::dst', 'simple.tgz')
+        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=none')
+        self.cmd(f'--repo={self.repository_location}::src', 'create', 'input')
+        self.cmd(f'--repo={self.repository_location}::src', 'export-tar', 'simple.tgz', f'--tar-format={tar_format}')
+        self.cmd(f'--repo={self.repository_location}::dst', 'import-tar', 'simple.tgz')
         with changedir(self.output_path):
-            self.cmd('extract', self.repository_location + '::dst')
+            self.cmd(f'--repo={self.repository_location}::dst', 'extract')
         self.assert_dirs_equal('input', 'output/input', ignore_ns=True, ignore_xattrs=True)
 
     def test_roundtrip_pax_borg(self):
         self.create_test_files()
-        self.cmd('init', '--encryption=none', self.repository_location)
-        self.cmd('create', self.repository_location + '::src', 'input')
-        self.cmd('export-tar', self.repository_location + '::src', 'simple.tar', '--tar-format=BORG')
-        self.cmd('import-tar', self.repository_location + '::dst', 'simple.tar')
+        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=none')
+        self.cmd(f'--repo={self.repository_location}::src', 'create', 'input')
+        self.cmd(f'--repo={self.repository_location}::src', 'export-tar', 'simple.tar', '--tar-format=BORG')
+        self.cmd(f'--repo={self.repository_location}::dst', 'import-tar', 'simple.tar')
         with changedir(self.output_path):
-            self.cmd('extract', self.repository_location + '::dst')
+            self.cmd(f'--repo={self.repository_location}::dst', 'extract')
         self.assert_dirs_equal('input', 'output/input')
 
     # derived from test_extract_xattrs_errors()
@@ -3489,16 +3488,16 @@ id: 2 / e29442 3506da 4e1ea7 / 25f62a 5a3d41 - 02
 
         os.makedirs(os.path.join(self.input_path, 'dir%p'))
         xattr.setxattr(b'input/dir%p', b'user.attribute', b'value')
-        self.cmd('init', self.repository_location, '-e' 'none')
-        self.cmd('create', self.repository_location + '::test', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'init', '-e' 'none')
+        self.cmd(f'--repo={self.repository_location}::test', 'create', 'input')
         with changedir('output'):
             with patch.object(xattr, 'setxattr', patched_setxattr_EACCES):
-                self.cmd('extract', self.repository_location + '::test', exit_code=EXIT_WARNING)
+                self.cmd(f'--repo={self.repository_location}::test', 'extract', exit_code=EXIT_WARNING)
 
     def test_do_not_mention_archive_if_you_can_not_find_repo(self):
         """https://github.com/borgbackup/borg/issues/6014"""
-        archive = self.repository_location + '-this-repository-does-not-exist' + '::test'
-        output = self.cmd('info', archive, exit_code=2, fork=True)
+        output = self.cmd(f'--repo={self.repository_location}-this-repository-does-not-exist::test', 'info',
+                          exit_code=2, fork=True)
         self.assert_in('this-repository-does-not-exist', output)
         self.assert_not_in('this-repository-does-not-exist::test', output)
 
@@ -3508,8 +3507,8 @@ id: 2 / e29442 3506da 4e1ea7 / 25f62a 5a3d41 - 02
         It should be possible to retrieve the data from an archive even if
         both the client and the server forget the nonce"""
         self.create_regular_file('file1', contents=b'Hello, borg')
-        self.cmd('init', '--encryption=repokey', self.repository_location)
-        self.cmd('create', self.repository_location + '::test', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}::test', 'create', 'input')
         # Oops! We have removed the repo-side memory of the nonce!
         # See https://github.com/borgbackup/borg/issues/5858
         os.remove(os.path.join(self.repository_path, 'nonce'))
@@ -3517,18 +3516,18 @@ id: 2 / e29442 3506da 4e1ea7 / 25f62a 5a3d41 - 02
         os.remove(os.path.join(self.get_security_dir(), 'nonce'))
 
         # The repo should still be readable
-        repo_info = self.cmd('info', self.repository_location)
+        repo_info = self.cmd(f'--repo={self.repository_location}', 'info')
         assert 'All archives:' in repo_info
-        repo_list = self.cmd('list', self.repository_location)
+        repo_list = self.cmd(f'--repo={self.repository_location}', 'list')
         assert 'test' in repo_list
         # The archive should still be readable
-        archive_info = self.cmd('info', self.repository_location + '::test')
+        archive_info = self.cmd(f'--repo={self.repository_location}::test', 'info')
         assert 'Archive name: test\n' in archive_info
-        archive_list = self.cmd('list', self.repository_location + '::test')
+        archive_list = self.cmd(f'--repo={self.repository_location}::test', 'list')
         assert 'file1' in archive_list
         # Extracting the archive should work
         with changedir('output'):
-            self.cmd('extract', self.repository_location + '::test')
+            self.cmd(f'--repo={self.repository_location}::test', 'extract')
         self.assert_dirs_equal('input', 'output/input')
 
     def test_recovery_from_deleted_repo_nonce(self):
@@ -3539,35 +3538,35 @@ id: 2 / e29442 3506da 4e1ea7 / 25f62a 5a3d41 - 02
         repo. Otherwise we can just use our own copy of the nonce.
         """
         self.create_regular_file('file1', contents=b'Hello, borg')
-        self.cmd('init', '--encryption=repokey', self.repository_location)
-        self.cmd('create', self.repository_location + '::test', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}::test', 'create', 'input')
         # Oops! We have removed the repo-side memory of the nonce!
         # See https://github.com/borgbackup/borg/issues/5858
         nonce = os.path.join(self.repository_path, 'nonce')
         os.remove(nonce)
 
-        self.cmd('create', self.repository_location + '::test2', 'input')
+        self.cmd(f'--repo={self.repository_location}::test2', 'create', 'input')
         assert os.path.exists(nonce)
 
     def test_init_defaults_to_argon2(self):
         """https://github.com/borgbackup/borg/issues/747#issuecomment-1076160401"""
-        self.cmd('init', '--encryption=repokey', self.repository_location)
+        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
         with Repository(self.repository_path) as repository:
             key = msgpack.unpackb(a2b_base64(repository.load_key()))
         assert key['algorithm'] == 'argon2 chacha20-poly1305'
 
     def test_init_with_explicit_key_algorithm(self):
         """https://github.com/borgbackup/borg/issues/747#issuecomment-1076160401"""
-        self.cmd('init', '--encryption=repokey', '--key-algorithm=pbkdf2', self.repository_location)
+        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey', '--key-algorithm=pbkdf2')
         with Repository(self.repository_path) as repository:
             key = msgpack.unpackb(a2b_base64(repository.load_key()))
         assert key['algorithm'] == 'sha256'
 
     def verify_change_passphrase_does_not_change_algorithm(self, given_algorithm, expected_algorithm):
-        self.cmd('init', '--encryption=repokey', '--key-algorithm', given_algorithm, self.repository_location)
+        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey', '--key-algorithm', given_algorithm)
         os.environ['BORG_NEW_PASSPHRASE'] = 'newpassphrase'
 
-        self.cmd('key', 'change-passphrase', self.repository_location)
+        self.cmd(f'--repo={self.repository_location}', 'key', 'change-passphrase')
 
         with Repository(self.repository_path) as repository:
             key = msgpack.unpackb(a2b_base64(repository.load_key()))
@@ -3580,9 +3579,9 @@ id: 2 / e29442 3506da 4e1ea7 / 25f62a 5a3d41 - 02
         self.verify_change_passphrase_does_not_change_algorithm('pbkdf2', 'sha256')
 
     def verify_change_location_does_not_change_algorithm(self, given_algorithm, expected_algorithm):
-        self.cmd('init', '--encryption=keyfile', '--key-algorithm', given_algorithm, self.repository_location)
+        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=keyfile', '--key-algorithm', given_algorithm)
 
-        self.cmd('key', 'change-location', self.repository_location, 'repokey')
+        self.cmd(f'--repo={self.repository_location}', 'key', 'change-location', 'repokey')
 
         with Repository(self.repository_path) as repository:
             key = msgpack.unpackb(a2b_base64(repository.load_key()))
@@ -3595,14 +3594,14 @@ id: 2 / e29442 3506da 4e1ea7 / 25f62a 5a3d41 - 02
         self.verify_change_location_does_not_change_algorithm('pbkdf2', 'sha256')
 
     def test_key_change_algorithm(self):
-        self.cmd('init', '--encryption=repokey', '--key-algorithm=pbkdf2', self.repository_location)
+        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey', '--key-algorithm=pbkdf2')
 
-        self.cmd('key', 'change-algorithm', self.repository_location, 'argon2')
+        self.cmd(f'--repo={self.repository_location}', 'key', 'change-algorithm', 'argon2')
 
         with Repository(self.repository_path) as repository:
             _, key = Manifest.load(repository, Manifest.NO_OPERATION_CHECK)
         assert key._encrypted_key_algorithm == 'argon2 chacha20-poly1305'
-        self.cmd('info', self.repository_location)
+        self.cmd(f'--repo={self.repository_location}', 'info')
 
 
 @unittest.skipUnless('binary' in BORG_EXES, 'no borg.exe available')
@@ -3654,30 +3653,30 @@ class ArchiverCheckTestCase(ArchiverTestCaseBase):
     def setUp(self):
         super().setUp()
         with patch.object(ChunkBuffer, 'BUFFER_SIZE', 10):
-            self.cmd('init', '--encryption=repokey', self.repository_location)
+            self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
             self.create_src_archive('archive1')
             self.create_src_archive('archive2')
 
     def test_check_usage(self):
-        output = self.cmd('check', '-v', '--progress', self.repository_location, exit_code=0)
+        output = self.cmd(f'--repo={self.repository_location}', 'check', '-v', '--progress', exit_code=0)
         self.assert_in('Starting repository check', output)
         self.assert_in('Starting archive consistency check', output)
         self.assert_in('Checking segments', output)
         # reset logging to new process default to avoid need for fork=True on next check
         logging.getLogger('borg.output.progress').setLevel(logging.NOTSET)
-        output = self.cmd('check', '-v', '--repository-only', self.repository_location, exit_code=0)
+        output = self.cmd(f'--repo={self.repository_location}', 'check', '-v', '--repository-only', exit_code=0)
         self.assert_in('Starting repository check', output)
         self.assert_not_in('Starting archive consistency check', output)
         self.assert_not_in('Checking segments', output)
-        output = self.cmd('check', '-v', '--archives-only', self.repository_location, exit_code=0)
+        output = self.cmd(f'--repo={self.repository_location}', 'check', '-v', '--archives-only', exit_code=0)
         self.assert_not_in('Starting repository check', output)
         self.assert_in('Starting archive consistency check', output)
-        output = self.cmd('check', '-v', '--archives-only', '--prefix=archive2', self.repository_location, exit_code=0)
+        output = self.cmd(f'--repo={self.repository_location}', 'check', '-v', '--archives-only', '--prefix=archive2', exit_code=0)
         self.assert_not_in('archive1', output)
-        output = self.cmd('check', '-v', '--archives-only', '--first=1', self.repository_location, exit_code=0)
+        output = self.cmd(f'--repo={self.repository_location}', 'check', '-v', '--archives-only', '--first=1', exit_code=0)
         self.assert_in('archive1', output)
         self.assert_not_in('archive2', output)
-        output = self.cmd('check', '-v', '--archives-only', '--last=1', self.repository_location, exit_code=0)
+        output = self.cmd(f'--repo={self.repository_location}', 'check', '-v', '--archives-only', '--last=1', exit_code=0)
         self.assert_not_in('archive1', output)
         self.assert_in('archive2', output)
 
@@ -3693,11 +3692,11 @@ class ArchiverCheckTestCase(ArchiverTestCaseBase):
             else:
                 self.fail('should not happen')
             repository.commit(compact=False)
-        self.cmd('check', self.repository_location, exit_code=1)
-        output = self.cmd('check', '--repair', self.repository_location, exit_code=0)
+        self.cmd(f'--repo={self.repository_location}', 'check', exit_code=1)
+        output = self.cmd(f'--repo={self.repository_location}', 'check', '--repair', exit_code=0)
         self.assert_in('New missing file chunk detected', output)
-        self.cmd('check', self.repository_location, exit_code=0)
-        output = self.cmd('list', '--format={health}#{path}{LF}', self.repository_location + '::archive1', exit_code=0)
+        self.cmd(f'--repo={self.repository_location}', 'check', exit_code=0)
+        output = self.cmd(f'--repo={self.repository_location}::archive1', 'list', '--format={health}#{path}{LF}', exit_code=0)
         self.assert_in('broken#', output)
         # check that the file in the old archives has now a different chunk list without the killed chunk
         for archive_name in ('archive1', 'archive2'):
@@ -3714,7 +3713,7 @@ class ArchiverCheckTestCase(ArchiverTestCaseBase):
         with patch.object(ChunkBuffer, 'BUFFER_SIZE', 10):
             self.create_src_archive('archive3')
         # check should be able to heal the file now:
-        output = self.cmd('check', '-v', '--repair', self.repository_location, exit_code=0)
+        output = self.cmd(f'--repo={self.repository_location}', 'check', '-v', '--repair', exit_code=0)
         self.assert_in('Healed previously missing file chunk', output)
         self.assert_in('testsuite/archiver.py: Completely healed previously damaged file!', output)
         # check that the file in the old archives has the correct chunks again
@@ -3728,7 +3727,7 @@ class ArchiverCheckTestCase(ArchiverTestCaseBase):
                 else:
                     self.fail('should not happen')
         # list is also all-healthy again
-        output = self.cmd('list', '--format={health}#{path}{LF}', self.repository_location + '::archive1', exit_code=0)
+        output = self.cmd(f'--repo={self.repository_location}::archive1', 'list', '--format={health}#{path}{LF}', exit_code=0)
         self.assert_not_in('broken#', output)
 
     def test_missing_archive_item_chunk(self):
@@ -3736,29 +3735,29 @@ class ArchiverCheckTestCase(ArchiverTestCaseBase):
         with repository:
             repository.delete(archive.metadata.items[0])
             repository.commit(compact=False)
-        self.cmd('check', self.repository_location, exit_code=1)
-        self.cmd('check', '--repair', self.repository_location, exit_code=0)
-        self.cmd('check', self.repository_location, exit_code=0)
+        self.cmd(f'--repo={self.repository_location}', 'check', exit_code=1)
+        self.cmd(f'--repo={self.repository_location}', 'check', '--repair', exit_code=0)
+        self.cmd(f'--repo={self.repository_location}', 'check', exit_code=0)
 
     def test_missing_archive_metadata(self):
         archive, repository = self.open_archive('archive1')
         with repository:
             repository.delete(archive.id)
             repository.commit(compact=False)
-        self.cmd('check', self.repository_location, exit_code=1)
-        self.cmd('check', '--repair', self.repository_location, exit_code=0)
-        self.cmd('check', self.repository_location, exit_code=0)
+        self.cmd(f'--repo={self.repository_location}', 'check', exit_code=1)
+        self.cmd(f'--repo={self.repository_location}', 'check', '--repair', exit_code=0)
+        self.cmd(f'--repo={self.repository_location}', 'check', exit_code=0)
 
     def test_missing_manifest(self):
         archive, repository = self.open_archive('archive1')
         with repository:
             repository.delete(Manifest.MANIFEST_ID)
             repository.commit(compact=False)
-        self.cmd('check', self.repository_location, exit_code=1)
-        output = self.cmd('check', '-v', '--repair', self.repository_location, exit_code=0)
+        self.cmd(f'--repo={self.repository_location}', 'check', exit_code=1)
+        output = self.cmd(f'--repo={self.repository_location}', 'check', '-v', '--repair', exit_code=0)
         self.assert_in('archive1', output)
         self.assert_in('archive2', output)
-        self.cmd('check', self.repository_location, exit_code=0)
+        self.cmd(f'--repo={self.repository_location}', 'check', exit_code=0)
 
     def test_corrupted_manifest(self):
         archive, repository = self.open_archive('archive1')
@@ -3767,11 +3766,11 @@ class ArchiverCheckTestCase(ArchiverTestCaseBase):
             corrupted_manifest = manifest + b'corrupted!'
             repository.put(Manifest.MANIFEST_ID, corrupted_manifest)
             repository.commit(compact=False)
-        self.cmd('check', self.repository_location, exit_code=1)
-        output = self.cmd('check', '-v', '--repair', self.repository_location, exit_code=0)
+        self.cmd(f'--repo={self.repository_location}', 'check', exit_code=1)
+        output = self.cmd(f'--repo={self.repository_location}', 'check', '-v', '--repair', exit_code=0)
         self.assert_in('archive1', output)
         self.assert_in('archive2', output)
-        self.cmd('check', self.repository_location, exit_code=0)
+        self.cmd(f'--repo={self.repository_location}', 'check', exit_code=0)
 
     def test_manifest_rebuild_corrupted_chunk(self):
         archive, repository = self.open_archive('archive1')
@@ -3784,10 +3783,10 @@ class ArchiverCheckTestCase(ArchiverTestCaseBase):
             corrupted_chunk = chunk + b'corrupted!'
             repository.put(archive.id, corrupted_chunk)
             repository.commit(compact=False)
-        self.cmd('check', self.repository_location, exit_code=1)
-        output = self.cmd('check', '-v', '--repair', self.repository_location, exit_code=0)
+        self.cmd(f'--repo={self.repository_location}', 'check', exit_code=1)
+        output = self.cmd(f'--repo={self.repository_location}', 'check', '-v', '--repair', exit_code=0)
         self.assert_in('archive2', output)
-        self.cmd('check', self.repository_location, exit_code=0)
+        self.cmd(f'--repo={self.repository_location}', 'check', exit_code=0)
 
     def test_manifest_rebuild_duplicate_archive(self):
         archive, repository = self.open_archive('archive1')
@@ -3809,27 +3808,27 @@ class ArchiverCheckTestCase(ArchiverTestCaseBase):
             archive_id = key.id_hash(archive)
             repository.put(archive_id, key.encrypt(archive_id, archive))
             repository.commit(compact=False)
-        self.cmd('check', self.repository_location, exit_code=1)
-        self.cmd('check', '--repair', self.repository_location, exit_code=0)
-        output = self.cmd('list', self.repository_location)
+        self.cmd(f'--repo={self.repository_location}', 'check', exit_code=1)
+        self.cmd(f'--repo={self.repository_location}', 'check', '--repair', exit_code=0)
+        output = self.cmd(f'--repo={self.repository_location}', 'list')
         self.assert_in('archive1', output)
         self.assert_in('archive1.1', output)
         self.assert_in('archive2', output)
 
     def test_extra_chunks(self):
-        self.cmd('check', self.repository_location, exit_code=0)
+        self.cmd(f'--repo={self.repository_location}', 'check', exit_code=0)
         with Repository(self.repository_location, exclusive=True) as repository:
             repository.put(b'01234567890123456789012345678901', b'xxxx')
             repository.commit(compact=False)
-        self.cmd('check', self.repository_location, exit_code=1)
-        self.cmd('check', self.repository_location, exit_code=1)
-        self.cmd('check', '--repair', self.repository_location, exit_code=0)
-        self.cmd('check', self.repository_location, exit_code=0)
-        self.cmd('extract', '--dry-run', self.repository_location + '::archive1', exit_code=0)
+        self.cmd(f'--repo={self.repository_location}', 'check', exit_code=1)
+        self.cmd(f'--repo={self.repository_location}', 'check', exit_code=1)
+        self.cmd(f'--repo={self.repository_location}', 'check', '--repair', exit_code=0)
+        self.cmd(f'--repo={self.repository_location}', 'check', exit_code=0)
+        self.cmd(f'--repo={self.repository_location}::archive1', 'extract', '--dry-run', exit_code=0)
 
     def _test_verify_data(self, *init_args):
         shutil.rmtree(self.repository_path)
-        self.cmd('init', self.repository_location, *init_args)
+        self.cmd(f'--repo={self.repository_location}', 'init', *init_args)
         self.create_src_archive('archive1')
         archive, repository = self.open_archive('archive1')
         with repository:
@@ -3840,11 +3839,11 @@ class ArchiverCheckTestCase(ArchiverTestCaseBase):
                     repository.put(chunk.id, data)
                     break
             repository.commit(compact=False)
-        self.cmd('check', self.repository_location, exit_code=0)
-        output = self.cmd('check', '--verify-data', self.repository_location, exit_code=1)
+        self.cmd(f'--repo={self.repository_location}', 'check', exit_code=0)
+        output = self.cmd(f'--repo={self.repository_location}', 'check', '--verify-data', exit_code=1)
         assert bin_to_hex(chunk.id) + ', integrity error' in output
         # repair (heal is tested in another test)
-        output = self.cmd('check', '--repair', '--verify-data', self.repository_location, exit_code=0)
+        output = self.cmd(f'--repo={self.repository_location}', 'check', '--repair', '--verify-data', exit_code=0)
         assert bin_to_hex(chunk.id) + ', integrity error' in output
         assert 'testsuite/archiver.py: New missing file chunk detected' in output
 
@@ -3859,7 +3858,7 @@ class ArchiverCheckTestCase(ArchiverTestCaseBase):
             for id_ in repository.list():
                 repository.delete(id_)
             repository.commit(compact=False)
-        self.cmd('check', self.repository_location, exit_code=1)
+        self.cmd(f'--repo={self.repository_location}', 'check', exit_code=1)
 
 
 class ManifestAuthenticationTest(ArchiverTestCaseBase):
@@ -3875,7 +3874,7 @@ class ManifestAuthenticationTest(ArchiverTestCaseBase):
             repository.commit(compact=False)
 
     def test_fresh_init_tam_required(self):
-        self.cmd('init', '--encryption=repokey', self.repository_location)
+        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
         repository = Repository(self.repository_path, exclusive=True)
         with repository:
             manifest, key = Manifest.load(repository, Manifest.NO_OPERATION_CHECK)
@@ -3887,10 +3886,10 @@ class ManifestAuthenticationTest(ArchiverTestCaseBase):
             repository.commit(compact=False)
 
         with pytest.raises(TAMRequiredError):
-            self.cmd('list', self.repository_location)
+            self.cmd(f'--repo={self.repository_location}', 'list')
 
     def test_not_required(self):
-        self.cmd('init', '--encryption=repokey', self.repository_location)
+        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
         self.create_src_archive('archive1234')
         repository = Repository(self.repository_path, exclusive=True)
         with repository:
@@ -3903,39 +3902,39 @@ class ManifestAuthenticationTest(ArchiverTestCaseBase):
             del manifest['tam']
             repository.put(Manifest.MANIFEST_ID, key.encrypt(Manifest.MANIFEST_ID, msgpack.packb(manifest)))
             repository.commit(compact=False)
-        output = self.cmd('list', '--debug', self.repository_location)
+        output = self.cmd(f'--repo={self.repository_location}', 'list', '--debug')
         assert 'archive1234' in output
         assert 'TAM not found and not required' in output
         # Run upgrade
-        self.cmd('upgrade', '--tam', self.repository_location)
+        self.cmd(f'--repo={self.repository_location}', 'upgrade', '--tam')
         # Manifest must be authenticated now
-        output = self.cmd('list', '--debug', self.repository_location)
+        output = self.cmd(f'--repo={self.repository_location}', 'list', '--debug')
         assert 'archive1234' in output
         assert 'TAM-verified manifest' in output
         # Try to spoof / modify pre-1.0.9
         self.spoof_manifest(repository)
         # Fails
         with pytest.raises(TAMRequiredError):
-            self.cmd('list', self.repository_location)
+            self.cmd(f'--repo={self.repository_location}', 'list')
         # Force upgrade
-        self.cmd('upgrade', '--tam', '--force', self.repository_location)
-        self.cmd('list', self.repository_location)
+        self.cmd(f'--repo={self.repository_location}', 'upgrade', '--tam', '--force')
+        self.cmd(f'--repo={self.repository_location}', 'list')
 
     def test_disable(self):
-        self.cmd('init', '--encryption=repokey', self.repository_location)
+        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
         self.create_src_archive('archive1234')
-        self.cmd('upgrade', '--disable-tam', self.repository_location)
+        self.cmd(f'--repo={self.repository_location}', 'upgrade', '--disable-tam')
         repository = Repository(self.repository_path, exclusive=True)
         self.spoof_manifest(repository)
-        assert not self.cmd('list', self.repository_location)
+        assert not self.cmd(f'--repo={self.repository_location}', 'list')
 
     def test_disable2(self):
-        self.cmd('init', '--encryption=repokey', self.repository_location)
+        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
         self.create_src_archive('archive1234')
         repository = Repository(self.repository_path, exclusive=True)
         self.spoof_manifest(repository)
-        self.cmd('upgrade', '--disable-tam', self.repository_location)
-        assert not self.cmd('list', self.repository_location)
+        self.cmd(f'--repo={self.repository_location}', 'upgrade', '--disable-tam')
+        assert not self.cmd(f'--repo={self.repository_location}', 'list')
 
 
 class RemoteArchiverTestCase(ArchiverTestCase):
@@ -3947,32 +3946,32 @@ class RemoteArchiverTestCase(ArchiverTestCase):
     def test_remote_repo_restrict_to_path(self):
         # restricted to repo directory itself:
         with patch.object(RemoteRepository, 'extra_test_args', ['--restrict-to-path', self.repository_path]):
-            self.cmd('init', '--encryption=repokey', self.repository_location)
+            self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
         # restricted to repo directory itself, fail for other directories with same prefix:
         with patch.object(RemoteRepository, 'extra_test_args', ['--restrict-to-path', self.repository_path]):
             with pytest.raises(PathNotAllowed):
-                self.cmd('init', '--encryption=repokey', self.repository_location + '_0')
+                self.cmd(f'--repo={self.repository_location}_0', 'init', '--encryption=repokey')
 
         # restricted to a completely different path:
         with patch.object(RemoteRepository, 'extra_test_args', ['--restrict-to-path', '/foo']):
             with pytest.raises(PathNotAllowed):
-                self.cmd('init', '--encryption=repokey', self.repository_location + '_1')
+                self.cmd(f'--repo={self.repository_location}_1', 'init', '--encryption=repokey')
         path_prefix = os.path.dirname(self.repository_path)
         # restrict to repo directory's parent directory:
         with patch.object(RemoteRepository, 'extra_test_args', ['--restrict-to-path', path_prefix]):
-            self.cmd('init', '--encryption=repokey', self.repository_location + '_2')
+            self.cmd(f'--repo={self.repository_location}_2', 'init', '--encryption=repokey')
         # restrict to repo directory's parent directory and another directory:
         with patch.object(RemoteRepository, 'extra_test_args', ['--restrict-to-path', '/foo', '--restrict-to-path', path_prefix]):
-            self.cmd('init', '--encryption=repokey', self.repository_location + '_3')
+            self.cmd(f'--repo={self.repository_location}_3', 'init', '--encryption=repokey')
 
     def test_remote_repo_restrict_to_repository(self):
         # restricted to repo directory itself:
         with patch.object(RemoteRepository, 'extra_test_args', ['--restrict-to-repository', self.repository_path]):
-            self.cmd('init', '--encryption=repokey', self.repository_location)
+            self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
         parent_path = os.path.join(self.repository_path, '..')
         with patch.object(RemoteRepository, 'extra_test_args', ['--restrict-to-repository', parent_path]):
             with pytest.raises(PathNotAllowed):
-                self.cmd('init', '--encryption=repokey', self.repository_location)
+                self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
 
     @unittest.skip('only works locally')
     def test_debug_put_get_delete_obj(self):
@@ -3987,25 +3986,25 @@ class RemoteArchiverTestCase(ArchiverTestCase):
         pass
 
     def test_remote_repo_strip_components_doesnt_leak(self):
-        self.cmd('init', '--encryption=repokey', self.repository_location)
+        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
         self.create_regular_file('dir/file', contents=b"test file contents 1")
         self.create_regular_file('dir/file2', contents=b"test file contents 2")
         self.create_regular_file('skipped-file1', contents=b"test file contents 3")
         self.create_regular_file('skipped-file2', contents=b"test file contents 4")
         self.create_regular_file('skipped-file3', contents=b"test file contents 5")
-        self.cmd('create', self.repository_location + '::test', 'input')
+        self.cmd(f'--repo={self.repository_location}::test', 'create', 'input')
         marker = 'cached responses left in RemoteRepository'
         with changedir('output'):
-            res = self.cmd('extract', "--debug", self.repository_location + '::test', '--strip-components', '3')
+            res = self.cmd(f'--repo={self.repository_location}::test', 'extract', "--debug", '--strip-components', '3')
             assert marker not in res
             with self.assert_creates_file('file'):
-                res = self.cmd('extract', "--debug", self.repository_location + '::test', '--strip-components', '2')
+                res = self.cmd(f'--repo={self.repository_location}::test', 'extract', "--debug", '--strip-components', '2')
                 assert marker not in res
             with self.assert_creates_file('dir/file'):
-                res = self.cmd('extract', "--debug", self.repository_location + '::test', '--strip-components', '1')
+                res = self.cmd(f'--repo={self.repository_location}::test', 'extract', "--debug", '--strip-components', '1')
                 assert marker not in res
             with self.assert_creates_file('input/dir/file'):
-                res = self.cmd('extract', "--debug", self.repository_location + '::test', '--strip-components', '0')
+                res = self.cmd(f'--repo={self.repository_location}::test', 'extract', "--debug", '--strip-components', '0')
                 assert marker not in res
 
 
@@ -4013,8 +4012,8 @@ class ArchiverCorruptionTestCase(ArchiverTestCaseBase):
     def setUp(self):
         super().setUp()
         self.create_test_files()
-        self.cmd('init', '--encryption=repokey', self.repository_location)
-        self.cache_path = json.loads(self.cmd('info', self.repository_location, '--json'))['cache']['path']
+        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cache_path = json.loads(self.cmd(f'--repo={self.repository_location}', 'info', '--json'))['cache']['path']
 
     def corrupt(self, file, amount=1):
         with open(file, 'r+b') as fd:
@@ -4027,28 +4026,28 @@ class ArchiverCorruptionTestCase(ArchiverTestCaseBase):
         self.corrupt(os.path.join(self.cache_path, 'chunks'))
 
         if self.FORK_DEFAULT:
-            out = self.cmd('info', self.repository_location, exit_code=2)
+            out = self.cmd(f'--repo={self.repository_location}', 'info', exit_code=2)
             assert 'failed integrity check' in out
         else:
             with pytest.raises(FileIntegrityError):
-                self.cmd('info', self.repository_location)
+                self.cmd(f'--repo={self.repository_location}', 'info')
 
     def test_cache_files(self):
-        self.cmd('create', self.repository_location + '::test', 'input')
+        self.cmd(f'--repo={self.repository_location}::test', 'create', 'input')
         self.corrupt(os.path.join(self.cache_path, 'files'))
-        out = self.cmd('create', self.repository_location + '::test1', 'input')
+        out = self.cmd(f'--repo={self.repository_location}::test1', 'create', 'input')
         # borg warns about the corrupt files cache, but then continues without files cache.
         assert 'files cache is corrupted' in out
 
     def test_chunks_archive(self):
-        self.cmd('create', self.repository_location + '::test1', 'input')
+        self.cmd(f'--repo={self.repository_location}::test1', 'create', 'input')
         # Find ID of test1 so we can corrupt it later :)
-        target_id = self.cmd('list', self.repository_location, '--format={id}{LF}').strip()
-        self.cmd('create', self.repository_location + '::test2', 'input')
+        target_id = self.cmd(f'--repo={self.repository_location}', 'list', '--format={id}{LF}').strip()
+        self.cmd(f'--repo={self.repository_location}::test2', 'create', 'input')
 
         # Force cache sync, creating archive chunks of test1 and test2 in chunks.archive.d
-        self.cmd('delete', '--cache-only', self.repository_location)
-        self.cmd('info', self.repository_location, '--json')
+        self.cmd(f'--repo={self.repository_location}', 'delete', '--cache-only')
+        self.cmd(f'--repo={self.repository_location}', 'info', '--json')
 
         chunks_archive = os.path.join(self.cache_path, 'chunks.archive.d')
         assert len(os.listdir(chunks_archive)) == 4  # two archives, one chunks cache and one .integrity file each
@@ -4064,7 +4063,7 @@ class ArchiverCorruptionTestCase(ArchiverTestCaseBase):
             config.write(fd)
 
         # Cache sync notices corrupted archive chunks, but automatically recovers.
-        out = self.cmd('create', '-v', self.repository_location + '::test3', 'input', exit_code=1)
+        out = self.cmd(f'--repo={self.repository_location}::test3', 'create', '-v', 'input', exit_code=1)
         assert 'Reading cached archive chunk index for test1' in out
         assert 'Cached archive chunk index of test1 is corrupted' in out
         assert 'Fetching and building archive index for test1' in out
@@ -4079,7 +4078,7 @@ class ArchiverCorruptionTestCase(ArchiverTestCaseBase):
         with open(config_path, 'w') as fd:
             config.write(fd)
 
-        out = self.cmd('info', self.repository_location)
+        out = self.cmd(f'--repo={self.repository_location}', 'info')
         assert 'Cache integrity data not available: old Borg version modified the cache.' in out
 
 
@@ -4107,10 +4106,10 @@ class DiffArchiverTestCase(ArchiverTestCaseBase):
             os.link('input/file_removed', 'input/hardlink_removed')
             os.link('input/file_removed2', 'input/hardlink_target_removed')
 
-        self.cmd('init', '--encryption=repokey', self.repository_location)
+        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
 
         # Create the first snapshot
-        self.cmd('create', self.repository_location + '::test0', 'input')
+        self.cmd(f'--repo={self.repository_location}::test0', 'create', 'input')
 
         # Setup files for the second snapshot
         self.create_regular_file('file_added', size=2048)
@@ -4141,8 +4140,8 @@ class DiffArchiverTestCase(ArchiverTestCaseBase):
             fd.write(b'appended_data')
 
         # Create the second snapshot
-        self.cmd('create', self.repository_location + '::test1a', 'input')
-        self.cmd('create', '--chunker-params', '16,18,17,4095', self.repository_location + '::test1b', 'input')
+        self.cmd(f'--repo={self.repository_location}::test1a', 'create', 'input')
+        self.cmd(f'--repo={self.repository_location}::test1b', 'create', '--chunker-params', '16,18,17,4095', 'input')
 
         def do_asserts(output, can_compare_ids):
             # File contents changed (deleted and replaced with a new file)
@@ -4287,19 +4286,19 @@ class DiffArchiverTestCase(ArchiverTestCaseBase):
             if are_hardlinks_supported():
                 assert not any(get_changes('input/hardlink_target_replaced', joutput))
 
-        do_asserts(self.cmd('diff', self.repository_location + '::test0', 'test1a'), True)
+        do_asserts(self.cmd(f'--repo={self.repository_location}::test0', 'diff', 'TODO_test0', 'test1a'), True)
         # We expect exit_code=1 due to the chunker params warning
-        do_asserts(self.cmd('diff', self.repository_location + '::test0', 'test1b', exit_code=1), False)
-        do_json_asserts(self.cmd('diff', self.repository_location + '::test0', 'test1a', '--json-lines'), True)
+        do_asserts(self.cmd(f'--repo={self.repository_location}::test0', 'diff', 'TODO_test0', 'test1b', exit_code=1), False)
+        do_json_asserts(self.cmd(f'--repo={self.repository_location}::test0', 'diff', 'TODO_test0', 'test1a', '--json-lines'), True)
 
     def test_sort_option(self):
-        self.cmd('init', '--encryption=repokey', self.repository_location)
+        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
 
         self.create_regular_file('a_file_removed', size=8)
         self.create_regular_file('f_file_removed', size=16)
         self.create_regular_file('c_file_changed', size=32)
         self.create_regular_file('e_file_changed', size=64)
-        self.cmd('create', self.repository_location + '::test0', 'input')
+        self.cmd(f'--repo={self.repository_location}::test0', 'create', 'input')
 
         os.unlink('input/a_file_removed')
         os.unlink('input/f_file_removed')
@@ -4309,9 +4308,9 @@ class DiffArchiverTestCase(ArchiverTestCaseBase):
         self.create_regular_file('e_file_changed', size=1024)
         self.create_regular_file('b_file_added', size=128)
         self.create_regular_file('d_file_added', size=256)
-        self.cmd('create', self.repository_location + '::test1', 'input')
+        self.cmd(f'--repo={self.repository_location}::test1', 'create', 'input')
 
-        output = self.cmd('diff', '--sort', self.repository_location + '::test0', 'test1')
+        output = self.cmd(f'--repo={self.repository_location}::test0', 'diff', '--sort', 'TODO_test0', 'test1')
         expected = [
             'a_file_removed',
             'b_file_added',
@@ -4353,7 +4352,7 @@ def test_get_args():
     assert args.restrict_to_repositories == ['/r1', '/r2']
     # trying to cheat - try to execute different subcommand
     args = archiver.get_args(['borg', 'serve', '--restrict-to-path=/p1', '--restrict-to-path=/p2', ],
-                             'borg init --encryption=repokey /')
+                             'borg --repo=/ init --encryption=repokey')
     assert args.func == archiver.do_serve
 
     # Check that environment variables in the forced command don't cause issues. If the command

From 1bf2a6a2409f41bb71ab4473fa79c5ef89d85759 Mon Sep 17 00:00:00 2001
From: Thomas Waldmann <tw@waldmann-edv.de>
Date: Wed, 15 Jun 2022 17:07:42 +0200
Subject: [PATCH 048/160] remove archive checks from location_validator, use
 --other-repo

---
 src/borg/archiver.py            | 19 ++++++++-----------
 src/borg/helpers/parseformat.py |  6 +-----
 2 files changed, 9 insertions(+), 16 deletions(-)

diff --git a/src/borg/archiver.py b/src/borg/archiver.py
index 0e2d07855..cea035ab0 100644
--- a/src/borg/archiver.py
+++ b/src/borg/archiver.py
@@ -4143,12 +4143,12 @@ class Archiver:
 
         # initialize DST_REPO reusing key material from SRC_REPO, so that
         # chunking and chunk id generation will work in the same way as before.
-        borg init --other-location=SRC_REPO --encryption=DST_ENC DST_REPO
+        borg --repo=DST_REPO init --other-repo=SRC_REPO --encryption=DST_ENC
 
         # transfer archives from SRC_REPO to DST_REPO
-        borg transfer --dry-run SRC_REPO DST_REPO  # check what it would do
-        borg transfer           SRC_REPO DST_REPO  # do it!
-        borg transfer --dry-run SRC_REPO DST_REPO  # check! anything left?
+        borg --repo=DST_REPO transfer --other-repo=SRC_REPO --dry-run  # check what it would do
+        borg --repo=DST_REPO transfer --other-repo=SRC_REPO            # do it!
+        borg --repo=DST_REPO transfer --other-repo=SRC_REPO --dry-run  # check! anything left?
 
         The default is to transfer all archives, including checkpoint archives.
 
@@ -4164,12 +4164,9 @@ class Archiver:
         subparser.set_defaults(func=self.do_transfer)
         subparser.add_argument('-n', '--dry-run', dest='dry_run', action='store_true',
                                help='do not change repository, just check')
-        subparser.add_argument('other_location', metavar='SRC_REPOSITORY',
-                               type=location_validator(archive=False, other=True),
+        subparser.add_argument('--other-repo', metavar='SRC_REPOSITORY', dest='other_location',
+                               type=location_validator(other=True),
                                help='source repository')
-        # subparser.add_argument('-r', '--repo', dest='location', metavar='DST_REPOSITORY',
-        #                        type=location_validator(archive=False, other=False),
-        #                        help='destination repository')
         define_archive_filters_group(subparser)
 
         # borg diff
@@ -4504,8 +4501,8 @@ class Archiver:
                                           formatter_class=argparse.RawDescriptionHelpFormatter,
                                           help='initialize empty repository')
         subparser.set_defaults(func=self.do_init)
-        subparser.add_argument('--other-location', metavar='OTHER_REPOSITORY', dest='other_location',
-                               type=location_validator(archive=False, other=True),
+        subparser.add_argument('--other-repo', metavar='SRC_REPOSITORY', dest='other_location',
+                               type=location_validator(other=True),
                                help='reuse the key material from the other repository')
         subparser.add_argument('-e', '--encryption', metavar='MODE', dest='encryption', required=True,
                                choices=key_argument_names(),
diff --git a/src/borg/helpers/parseformat.py b/src/borg/helpers/parseformat.py
index 43e8d05eb..e4b54f0c8 100644
--- a/src/borg/helpers/parseformat.py
+++ b/src/borg/helpers/parseformat.py
@@ -507,16 +507,12 @@ class Location:
         return loc
 
 
-def location_validator(archive=None, proto=None, other=False):
+def location_validator(proto=None, other=False):
     def validator(text):
         try:
             loc = Location(text, other=other)
         except ValueError as err:
             raise argparse.ArgumentTypeError(str(err)) from None
-        if archive is True and not loc.archive:
-            raise argparse.ArgumentTypeError('"%s": No archive specified' % text)
-        elif archive is False and loc.archive:
-            raise argparse.ArgumentTypeError('"%s": No archive can be specified' % text)
         if proto is not None and loc.proto != proto:
             if proto == 'file':
                 raise argparse.ArgumentTypeError('"%s": Repository must be local' % text)

From 0f0cd2435465a5e11fd320a4e2c21bc40ee9e254 Mon Sep 17 00:00:00 2001
From: Thomas Waldmann <tw@waldmann-edv.de>
Date: Wed, 15 Jun 2022 17:44:38 +0200
Subject: [PATCH 049/160] if --(other-)repo option is not given, use default
 from environment

remove tests composing a repo+archive location with repo from env
and location from cli.
---
 src/borg/archiver.py            | 17 ++++---
 src/borg/helpers/parseformat.py | 45 ++++++++-----------
 src/borg/testsuite/helpers.py   | 80 ---------------------------------
 3 files changed, 29 insertions(+), 113 deletions(-)

diff --git a/src/borg/archiver.py b/src/borg/archiver.py
index cea035ab0..1b668f618 100644
--- a/src/borg/archiver.py
+++ b/src/borg/archiver.py
@@ -174,8 +174,10 @@ def with_repository(fake=False, invert_fake=False, create=False, lock=True,
     def decorator(method):
         @functools.wraps(method)
         def wrapper(self, args, **kwargs):
+            location = getattr(args, 'location')
+            if not location.valid:  # location always must be given
+                raise Error('missing repository, please use --repo or BORG_REPO env var!')
             lock = getattr(args, 'lock', _lock)
-            location = args.location  # note: 'location' must be always present in args
             append_only = getattr(args, 'append_only', False)
             storage_quota = getattr(args, 'storage_quota', None)
             make_parent_dirs = getattr(args, 'make_parent_dirs', False)
@@ -220,8 +222,8 @@ def with_other_repository(manifest=False, key=False, cache=False, compatibility=
     def decorator(method):
         @functools.wraps(method)
         def wrapper(self, args, **kwargs):
-            location = getattr(args, 'other_location', None)
-            if location is None:  # nothing to do
+            location = getattr(args, 'other_location')
+            if not location.valid:  # nothing to do
                 return method(self, args, **kwargs)
 
             repository = get_repository(location, create=False, exclusive=True,
@@ -3203,8 +3205,9 @@ class Archiver:
                                    'compatible file can be generated by suffixing FILE with ".pyprof".')
             add_common_option('--rsh', metavar='RSH', dest='rsh',
                               help="Use this command to connect to the 'borg serve' process (default: 'ssh')")
-            add_common_option('--repo', metavar='REPO', dest='location', type=location_validator(),
-                              help="repository to use")  # XXXYYY
+            add_common_option('--repo', metavar='REPO', dest='location',
+                              type=location_validator(other=False), default=Location(other=False),
+                              help="repository to use")
 
         def define_exclude_and_patterns(add_option, *, tag_files=False, strip_components=False):
             add_option('-e', '--exclude', metavar='PATTERN', dest='patterns',
@@ -4165,7 +4168,7 @@ class Archiver:
         subparser.add_argument('-n', '--dry-run', dest='dry_run', action='store_true',
                                help='do not change repository, just check')
         subparser.add_argument('--other-repo', metavar='SRC_REPOSITORY', dest='other_location',
-                               type=location_validator(other=True),
+                               type=location_validator(other=True), default=Location(other=True),
                                help='source repository')
         define_archive_filters_group(subparser)
 
@@ -4502,7 +4505,7 @@ class Archiver:
                                           help='initialize empty repository')
         subparser.set_defaults(func=self.do_init)
         subparser.add_argument('--other-repo', metavar='SRC_REPOSITORY', dest='other_location',
-                               type=location_validator(other=True),
+                               type=location_validator(other=True), default=Location(other=True),
                                help='reuse the key material from the other repository')
         subparser.add_argument('-e', '--encryption', metavar='MODE', dest='encryption', required=True,
                                choices=key_argument_names(),
diff --git a/src/borg/helpers/parseformat.py b/src/borg/helpers/parseformat.py
index e4b54f0c8..7c25437b0 100644
--- a/src/borg/helpers/parseformat.py
+++ b/src/borg/helpers/parseformat.py
@@ -365,15 +365,6 @@ class Location:
     local_re = re.compile(
         local_path_re + optional_archive_re, re.VERBOSE)    # local path with optional archive
 
-    # get the repo from BORG_REPO env and the optional archive from param.
-    # if the syntax requires giving REPOSITORY (see "borg mount"),
-    # use "::" to let it use the env var.
-    # if REPOSITORY argument is optional, it'll automatically use the env.
-    env_re = re.compile(r"""                                # the repo part is fetched from BORG_REPO
-        (?:::$)                                             # just "::" is ok (when a pos. arg is required, no archive)
-        |                                                   # or
-        """ + optional_archive_re, re.VERBOSE)              # archive name (optional, may be empty)
-
     win_file_re = re.compile(r"""
         (?:file://)?                                        # optional file protocol
         (?P<path>
@@ -384,27 +375,29 @@ class Location:
 
     def __init__(self, text='', overrides={}, other=False):
         self.repo_env_var = 'BORG_OTHER_REPO' if other else 'BORG_REPO'
-        if not self.parse(text, overrides):
-            raise ValueError('Invalid location format: "%s"' % self.processed)
+        self.valid = False
+        self.proto = None
+        self.user = None
+        self._host = None
+        self.port = None
+        self.path = None
+        self.archive = None
+        self.parse(text, overrides)
 
     def parse(self, text, overrides={}):
+        if not text:
+            # we did not get a text to parse, so we try to fetch from the environment
+            text = os.environ.get(self.repo_env_var)
+            if text is None:
+                return
+
         self.raw = text  # as given by user, might contain placeholders
-        self.processed = text = replace_placeholders(text, overrides)  # after placeholder replacement
-        valid = self._parse(text)
+        self.processed = replace_placeholders(self.raw, overrides)  # after placeholder replacement
+        valid = self._parse(self.processed)
         if valid:
-            return True
-        m = self.env_re.match(text)
-        if not m:
-            return False
-        repo_raw = os.environ.get(self.repo_env_var)
-        if repo_raw is None:
-            return False
-        repo = replace_placeholders(repo_raw, overrides)
-        valid = self._parse(repo)
-        self.archive = m.group('archive')
-        self.raw = repo_raw if not self.archive else repo_raw + self.raw
-        self.processed = repo if not self.archive else f'{repo}::{self.archive}'
-        return valid
+            self.valid = True
+        else:
+            raise ValueError('Invalid location format: "%s"' % self.processed)
 
     def _parse(self, text):
         def normpath_special(p):
diff --git a/src/borg/testsuite/helpers.py b/src/borg/testsuite/helpers.py
index fd0414116..81469a133 100644
--- a/src/borg/testsuite/helpers.py
+++ b/src/borg/testsuite/helpers.py
@@ -166,15 +166,6 @@ class TestLocationWithoutEnv:
         assert repr(Location('path::archive-{utcnow}').with_timestamp(datetime(2002, 9, 19, tzinfo=timezone.utc))) == \
             "Location(proto='file', user=None, host=None, port=None, path='path', archive='archive-2002-09-19T00:00:00')"
 
-    def test_underspecified(self, monkeypatch):
-        monkeypatch.delenv('BORG_REPO', raising=False)
-        with pytest.raises(ValueError):
-            Location('::archive')
-        with pytest.raises(ValueError):
-            Location('::')
-        with pytest.raises(ValueError):
-            Location()
-
     def test_no_slashes(self, monkeypatch):
         monkeypatch.delenv('BORG_REPO', raising=False)
         with pytest.raises(ValueError):
@@ -213,77 +204,6 @@ class TestLocationWithoutEnv:
         assert loc_without_archive.processed == "ssh://user@host:1234/repos/%s" % hostname
 
 
-class TestLocationWithEnv:
-    def test_ssh(self, monkeypatch):
-        monkeypatch.setenv('BORG_REPO', 'ssh://user@host:1234/some/path')
-        assert repr(Location('::archive')) == \
-            "Location(proto='ssh', user='user', host='host', port=1234, path='/some/path', archive='archive')"
-        assert repr(Location('::')) == \
-            "Location(proto='ssh', user='user', host='host', port=1234, path='/some/path', archive=None)"
-        assert repr(Location()) == \
-               "Location(proto='ssh', user='user', host='host', port=1234, path='/some/path', archive=None)"
-
-    def test_ssh_placeholder(self, monkeypatch):
-        from borg.platform import hostname
-        monkeypatch.setenv('BORG_REPO', 'ssh://user@host:1234/{hostname}')
-        assert repr(Location('::archive')) == \
-            f"Location(proto='ssh', user='user', host='host', port=1234, path='/{hostname}', archive='archive')"
-        assert repr(Location('::')) == \
-            f"Location(proto='ssh', user='user', host='host', port=1234, path='/{hostname}', archive=None)"
-        assert repr(Location()) == \
-            f"Location(proto='ssh', user='user', host='host', port=1234, path='/{hostname}', archive=None)"
-
-    def test_file(self, monkeypatch):
-        monkeypatch.setenv('BORG_REPO', 'file:///some/path')
-        assert repr(Location('::archive')) == \
-            "Location(proto='file', user=None, host=None, port=None, path='/some/path', archive='archive')"
-        assert repr(Location('::')) == \
-            "Location(proto='file', user=None, host=None, port=None, path='/some/path', archive=None)"
-        assert repr(Location()) == \
-               "Location(proto='file', user=None, host=None, port=None, path='/some/path', archive=None)"
-
-    def test_folder(self, monkeypatch):
-        monkeypatch.setenv('BORG_REPO', 'path')
-        assert repr(Location('::archive')) == \
-            "Location(proto='file', user=None, host=None, port=None, path='path', archive='archive')"
-        assert repr(Location('::')) == \
-            "Location(proto='file', user=None, host=None, port=None, path='path', archive=None)"
-        assert repr(Location()) == \
-               "Location(proto='file', user=None, host=None, port=None, path='path', archive=None)"
-
-    def test_abspath(self, monkeypatch):
-        monkeypatch.setenv('BORG_REPO', '/some/absolute/path')
-        assert repr(Location('::archive')) == \
-            "Location(proto='file', user=None, host=None, port=None, path='/some/absolute/path', archive='archive')"
-        assert repr(Location('::')) == \
-            "Location(proto='file', user=None, host=None, port=None, path='/some/absolute/path', archive=None)"
-        assert repr(Location()) == \
-               "Location(proto='file', user=None, host=None, port=None, path='/some/absolute/path', archive=None)"
-
-    def test_relpath(self, monkeypatch):
-        monkeypatch.setenv('BORG_REPO', 'some/relative/path')
-        assert repr(Location('::archive')) == \
-            "Location(proto='file', user=None, host=None, port=None, path='some/relative/path', archive='archive')"
-        assert repr(Location('::')) == \
-            "Location(proto='file', user=None, host=None, port=None, path='some/relative/path', archive=None)"
-        assert repr(Location()) == \
-               "Location(proto='file', user=None, host=None, port=None, path='some/relative/path', archive=None)"
-
-    def test_with_colons(self, monkeypatch):
-        monkeypatch.setenv('BORG_REPO', '/abs/path:w:cols')
-        assert repr(Location('::arch:col')) == \
-            "Location(proto='file', user=None, host=None, port=None, path='/abs/path:w:cols', archive='arch:col')"
-        assert repr(Location('::')) == \
-               "Location(proto='file', user=None, host=None, port=None, path='/abs/path:w:cols', archive=None)"
-        assert repr(Location()) == \
-               "Location(proto='file', user=None, host=None, port=None, path='/abs/path:w:cols', archive=None)"
-
-    def test_no_slashes(self, monkeypatch):
-        monkeypatch.setenv('BORG_REPO', '/some/absolute/path')
-        with pytest.raises(ValueError):
-            Location('::archive_name_with/slashes/is_invalid')
-
-
 class FormatTimedeltaTestCase(BaseTestCase):
 
     def test(self):

From 281bbbc16bafd6f2e8dff81ce8d1c704408f42ed Mon Sep 17 00:00:00 2001
From: Thomas Waldmann <tw@waldmann-edv.de>
Date: Wed, 15 Jun 2022 19:00:19 +0200
Subject: [PATCH 050/160] fix tests and benchmarks

---
 src/borg/archiver.py            | 106 +++--
 src/borg/fuse.py                |   4 +-
 src/borg/helpers/manifest.py    |   2 +-
 src/borg/helpers/parseformat.py |   2 +
 src/borg/testsuite/archiver.py  | 773 ++++++++++++++++----------------
 src/borg/testsuite/benchmark.py |  42 +-
 6 files changed, 477 insertions(+), 452 deletions(-)

diff --git a/src/borg/archiver.py b/src/borg/archiver.py
index 1b668f618..2e112fafe 100644
--- a/src/borg/archiver.py
+++ b/src/borg/archiver.py
@@ -52,7 +52,7 @@ try:
     from .helpers import EXIT_SUCCESS, EXIT_WARNING, EXIT_ERROR, EXIT_SIGNAL_BASE
     from .helpers import Error, NoManifestError, set_ec
     from .helpers import positive_int_validator, location_validator, archivename_validator, ChunkerParams, Location
-    from .helpers import PrefixSpec, GlobSpec, CommentSpec, SortBySpec, FilesCacheMode
+    from .helpers import PrefixSpec, GlobSpec, NameSpec, CommentSpec, SortBySpec, FilesCacheMode
     from .helpers import BaseFormatter, ItemFormatter, ArchiveFormatter
     from .helpers import format_timedelta, format_file_size, parse_file_size, format_archive
     from .helpers import remove_surrogates, bin_to_hex, prepare_dump_dict, eval_escapes
@@ -257,7 +257,9 @@ def with_other_repository(manifest=False, key=False, cache=False, compatibility=
 def with_archive(method):
     @functools.wraps(method)
     def wrapper(self, args, repository, key, manifest, **kwargs):
-        archive = Archive(repository, key, manifest, args.location.archive,
+        archive_name = getattr(args, 'name', None)
+        assert archive_name is not None
+        archive = Archive(repository, key, manifest, archive_name,
                           numeric_ids=getattr(args, 'numeric_ids', False),
                           noflags=getattr(args, 'nobsdflags', False) or getattr(args, 'noflags', False),
                           noacls=getattr(args, 'noacls', False),
@@ -541,7 +543,7 @@ class Archiver:
         if args.prefix is not None:
             args.glob_archives = args.prefix + '*'
         if not args.repo_only and not ArchiveChecker().check(
-                repository, repair=args.repair, archive=args.location.archive,
+                repository, repair=args.repair, archive=args.name,
                 first=args.first, last=args.last, sort_by=args.sort_by or 'ts', glob=args.glob_archives,
                 verify_data=args.verify_data, save_space=args.save_space):
             return EXIT_WARNING
@@ -669,34 +671,34 @@ class Archiver:
             compression = '--compression=none'
             # measure create perf (without files cache to always have it chunking)
             t_start = time.monotonic()
-            rc = self.do_create(self.parse_args([f'--repo={repo}::borg-benchmark-crud1', 'create',
+            rc = self.do_create(self.parse_args([f'--repo={repo}', 'create', '--name=borg-benchmark-crud1',
                                                  compression, '--files-cache=disabled', path]))
             t_end = time.monotonic()
             dt_create = t_end - t_start
             assert rc == 0
             # now build files cache
-            rc1 = self.do_create(self.parse_args([f'--repo={repo}::borg-benchmark-crud2', 'create',
+            rc1 = self.do_create(self.parse_args([f'--repo={repo}', 'create', '--name=borg-benchmark-crud2',
                                                   compression, path]))
-            rc2 = self.do_delete(self.parse_args([f'--repo={repo}::borg-benchmark-crud2', 'delete']))
+            rc2 = self.do_delete(self.parse_args([f'--repo={repo}', 'delete', '--name=borg-benchmark-crud2']))
             assert rc1 == rc2 == 0
             # measure a no-change update (archive1 is still present)
             t_start = time.monotonic()
-            rc1 = self.do_create(self.parse_args([f'--repo={repo}::borg-benchmark-crud3', 'create',
+            rc1 = self.do_create(self.parse_args([f'--repo={repo}', 'create', '--name=borg-benchmark-crud3',
                                                   compression, path]))
             t_end = time.monotonic()
             dt_update = t_end - t_start
-            rc2 = self.do_delete(self.parse_args([f'--repo={repo}::borg-benchmark-crud3', 'delete']))
+            rc2 = self.do_delete(self.parse_args([f'--repo={repo}', 'delete', '--name=borg-benchmark-crud3']))
             assert rc1 == rc2 == 0
             # measure extraction (dry-run: without writing result to disk)
             t_start = time.monotonic()
-            rc = self.do_extract(self.parse_args([f'--repo={repo}::borg-benchmark-crud1', 'extract',
+            rc = self.do_extract(self.parse_args([f'--repo={repo}', 'extract', '--name=borg-benchmark-crud1',
                                                   '--dry-run']))
             t_end = time.monotonic()
             dt_extract = t_end - t_start
             assert rc == 0
             # measure archive deletion (of LAST present archive with the data)
             t_start = time.monotonic()
-            rc = self.do_delete(self.parse_args([f'--repo={repo}::borg-benchmark-crud1', 'delete']))
+            rc = self.do_delete(self.parse_args([f'--repo={repo}', 'delete', '--name=borg-benchmark-crud1']))
             t_end = time.monotonic()
             dt_delete = t_end - t_start
             assert rc == 0
@@ -1012,7 +1014,7 @@ class Archiver:
             with Cache(repository, key, manifest, progress=args.progress,
                        lock_wait=self.lock_wait, permit_adhoc_cache=args.no_cache_sync,
                        cache_mode=args.files_cache_mode, iec=args.iec) as cache:
-                archive = Archive(repository, key, manifest, args.location.archive, cache=cache,
+                archive = Archive(repository, key, manifest, args.name, cache=cache,
                                   create=True, checkpoint_interval=args.checkpoint_interval,
                                   numeric_ids=args.numeric_ids, noatime=not args.atime, noctime=args.noctime,
                                   progress=args.progress,
@@ -1475,7 +1477,7 @@ class Archiver:
         print_output = print_json_output if args.json_lines else print_text_output
 
         archive1 = archive
-        archive2 = Archive(repository, key, manifest, args.archive2,
+        archive2 = Archive(repository, key, manifest, args.name2,
                            consider_part_files=args.consider_part_files)
 
         can_compare_chunk_ids = archive1.metadata.get('chunker_params', False) == archive2.metadata.get(
@@ -1506,7 +1508,7 @@ class Archiver:
     @with_archive
     def do_rename(self, args, repository, manifest, key, cache, archive):
         """Rename an existing archive"""
-        archive.rename(args.name)
+        archive.rename(args.name2)
         manifest.write()
         repository.commit(compact=False)
         cache.commit()
@@ -1516,7 +1518,7 @@ class Archiver:
     def do_delete(self, args, repository):
         """Delete an existing repository or archives"""
         archive_filter_specified = any((args.first, args.last, args.prefix is not None, args.glob_archives))
-        explicit_archives_specified = args.location.archive or args.archives
+        explicit_archives_specified = args.name or args.archives
         self.output_list = args.output_list
         if archive_filter_specified and explicit_archives_specified:
             self.print_error('Mixing archive filters and explicitly named archives is not supported.')
@@ -1532,10 +1534,10 @@ class Archiver:
 
         manifest, key = Manifest.load(repository, (Manifest.Operation.DELETE,))
 
-        if args.location.archive or args.archives:
+        if args.name or args.archives:
             archives = list(args.archives)
-            if args.location.archive:
-                archives.insert(0, args.location.archive)
+            if args.name:
+                archives.insert(0, args.name)
             archive_names = tuple(archives)
         else:
             args.consider_checkpoints = True
@@ -1699,7 +1701,7 @@ class Archiver:
     @with_repository(compatibility=(Manifest.Operation.READ,))
     def do_list(self, args, repository, manifest, key):
         """List archive or repository contents"""
-        if args.location.archive:
+        if args.name:
             if args.json:
                 self.print_error('The --json option is only valid for listing archives, not archive contents.')
                 return self.exit_code
@@ -1720,7 +1722,7 @@ class Archiver:
             format = "{mode} {user:6} {group:6} {size:8} {mtime} {path}{extra}{NL}"
 
         def _list_inner(cache):
-            archive = Archive(repository, key, manifest, args.location.archive, cache=cache,
+            archive = Archive(repository, key, manifest, args.name, cache=cache,
                               consider_part_files=args.consider_part_files)
 
             formatter = ItemFormatter(archive, format, json_lines=args.json_lines)
@@ -1763,7 +1765,7 @@ class Archiver:
     @with_repository(cache=True, compatibility=(Manifest.Operation.READ,))
     def do_info(self, args, repository, manifest, key, cache):
         """Show archive details such as disk space used"""
-        if any((args.location.archive, args.first, args.last, args.prefix is not None, args.glob_archives)):
+        if any((args.name, args.first, args.last, args.prefix is not None, args.glob_archives)):
             return self._info_archives(args, repository, manifest, key, cache)
         else:
             return self._info_repository(args, repository, manifest, key, cache)
@@ -1772,8 +1774,8 @@ class Archiver:
         def format_cmdline(cmdline):
             return remove_surrogates(' '.join(shlex.quote(x) for x in cmdline))
 
-        if args.location.archive:
-            archive_names = (args.location.archive,)
+        if args.name:
+            archive_names = (args.name,)
         else:
             args.consider_checkpoints = True
             archive_names = tuple(x.name for x in manifest.archives.list_considering(args))
@@ -2003,8 +2005,8 @@ class Archiver:
                                      checkpoint_interval=args.checkpoint_interval,
                                      dry_run=args.dry_run, timestamp=args.timestamp)
 
-        if args.location.archive:
-            name = args.location.archive
+        if args.name:
+            name = args.name
             if recreater.is_temporary_archive(name):
                 self.print_error('Refusing to work on temporary archive of prior recreate: %s', name)
                 return self.exit_code
@@ -2048,7 +2050,7 @@ class Archiver:
         t0 = datetime.utcnow()
         t0_monotonic = time.monotonic()
 
-        archive = Archive(repository, key, manifest, args.location.archive, cache=cache,
+        archive = Archive(repository, key, manifest, args.name, cache=cache,
                           create=True, checkpoint_interval=args.checkpoint_interval,
                           progress=args.progress,
                           chunker_params=args.chunker_params, start=t0, start_monotonic=t0_monotonic,
@@ -2289,7 +2291,7 @@ class Archiver:
     @with_repository(compatibility=Manifest.NO_OPERATION_CHECK)
     def do_debug_dump_archive_items(self, args, repository, manifest, key):
         """dump (decrypted, decompressed) archive items metadata (not: data)"""
-        archive = Archive(repository, key, manifest, args.location.archive,
+        archive = Archive(repository, key, manifest, args.name,
                           consider_part_files=args.consider_part_files)
         for i, item_id in enumerate(archive.metadata.items):
             data = key.decrypt(item_id, repository.get(item_id))
@@ -2305,9 +2307,9 @@ class Archiver:
         """dump decoded archive metadata (not: data)"""
 
         try:
-            archive_meta_orig = manifest.archives.get_raw_dict()[args.location.archive]
+            archive_meta_orig = manifest.archives.get_raw_dict()[args.name]
         except KeyError:
-            raise Archive.DoesNotExist(args.location.archive)
+            raise Archive.DoesNotExist(args.name)
 
         indent = 4
 
@@ -2317,7 +2319,7 @@ class Archiver:
         def output(fd):
             # this outputs megabytes of data for a modest sized archive, so some manual streaming json output
             fd.write('{\n')
-            fd.write('    "_name": ' + json.dumps(args.location.archive) + ",\n")
+            fd.write('    "_name": ' + json.dumps(args.name) + ",\n")
             fd.write('    "_manifest_entry":\n')
             fd.write(do_indent(prepare_dump_dict(archive_meta_orig)))
             fd.write(',\n')
@@ -2808,7 +2810,7 @@ class Archiver:
         This allows you to share the same patterns between multiple repositories
         without needing to specify them on the command line.\n\n''')
     helptext['placeholders'] = textwrap.dedent('''
-        Repository (or Archive) URLs, ``--prefix``, ``--glob-archives``, ``--comment``
+        Repository URLs, ``--name``, ``--prefix``, ``--glob-archives``, ``--comment``
         and ``--remote-path`` values support these placeholders:
 
         {hostname}
@@ -3271,7 +3273,8 @@ class Archiver:
 
         def define_borg_mount(parser):
             parser.set_defaults(func=self.do_mount)
-            # archive name
+            parser.add_argument('--name', dest='name', metavar='NAME', type=NameSpec,
+                                help='specify the archive name')
             parser.add_argument('--consider-checkpoints', action='store_true', dest='consider_checkpoints',
                                 help='Show checkpoint archives in the repository contents list (default: hidden).')
             parser.add_argument('mountpoint', metavar='MOUNTPOINT', type=str,
@@ -3545,7 +3548,8 @@ class Archiver:
                                           formatter_class=argparse.RawDescriptionHelpFormatter,
                                           help='verify repository')
         subparser.set_defaults(func=self.do_check)
-        # archive name
+        subparser.add_argument('--name', dest='name', metavar='NAME', type=NameSpec,
+                               help='specify the archive name')
         subparser.add_argument('--repository-only', dest='repo_only', action='store_true',
                                help='only perform repository checks')
         subparser.add_argument('--archives-only', dest='archives_only', action='store_true',
@@ -3895,6 +3899,8 @@ class Archiver:
                                    'regular files. Also follows symlinks pointing to these kinds of files.')
 
         archive_group = subparser.add_argument_group('Archive options')
+        archive_group.add_argument('--name', dest='name', metavar='NAME', type=NameSpec, default='{hostname}-{now}',
+                                   help='specify the name for the archive')
         archive_group.add_argument('--comment', dest='comment', metavar='COMMENT', type=CommentSpec, default='',
                                    help='add a comment text to the archive')
         archive_group.add_argument('--timestamp', metavar='TIMESTAMP', dest='timestamp',
@@ -3913,7 +3919,6 @@ class Archiver:
                                    help='select compression algorithm, see the output of the '
                                         '"borg help compression" command for details.')
 
-        # archive name
         subparser.add_argument('paths', metavar='PATH', nargs='*', type=str,
                                help='paths to archive')
 
@@ -3956,7 +3961,8 @@ class Archiver:
                                           formatter_class=argparse.RawDescriptionHelpFormatter,
                                           help='dump archive items (metadata) (debug)')
         subparser.set_defaults(func=self.do_debug_dump_archive_items)
-        # archive name
+        subparser.add_argument('--name', dest='name', metavar='NAME', type=NameSpec,
+                               help='specify the archive name')
 
         debug_dump_archive_epilog = process_epilog("""
         This command dumps all metadata of an archive in a decoded form to a file.
@@ -3967,7 +3973,8 @@ class Archiver:
                                           formatter_class=argparse.RawDescriptionHelpFormatter,
                                           help='dump decoded archive metadata (debug)')
         subparser.set_defaults(func=self.do_debug_dump_archive)
-        # archive name
+        subparser.add_argument('--name', dest='name', metavar='NAME', type=NameSpec,
+                               help='specify the archive name')
         subparser.add_argument('path', metavar='PATH', type=str,
                                help='file to dump data into')
 
@@ -4133,7 +4140,8 @@ class Archiver:
                                help='keep the local security info when deleting a repository')
         subparser.add_argument('--save-space', dest='save_space', action='store_true',
                                help='work slower, but using less space')
-        # archive name
+        subparser.add_argument('--name', dest='name', metavar='NAME', type=NameSpec,
+                               help='specify the archive name')
         subparser.add_argument('archives', metavar='ARCHIVE', nargs='*',
                                help='archives to delete')
         define_archive_filters_group(subparser)
@@ -4207,10 +4215,10 @@ class Archiver:
                                help='Sort the output lines by file path.')
         subparser.add_argument('--json-lines', action='store_true',
                                help='Format output as JSON Lines. ')
-        subparser.add_argument('archive1', metavar='ARCHIVE1',
+        subparser.add_argument('--name', metavar='ARCHIVE1',
                                type=archivename_validator(),
                                help='ARCHIVE1 name')
-        subparser.add_argument('archive2', metavar='ARCHIVE2',
+        subparser.add_argument('--name2', metavar='ARCHIVE2',
                                type=archivename_validator(),
                                help='ARCHIVE2 name')
         subparser.add_argument('paths', metavar='PATH', nargs='*', type=str,
@@ -4267,6 +4275,8 @@ class Archiver:
                                           formatter_class=argparse.RawDescriptionHelpFormatter,
                                           help='create tarball from archive')
         subparser.set_defaults(func=self.do_export_tar)
+        subparser.add_argument('--name', dest='name', metavar='NAME', type=NameSpec,
+                               help='specify the archive name')
         subparser.add_argument('--tar-filter', dest='tar_filter', default='auto',
                                help='filter program to pipe data through')
         subparser.add_argument('--list', dest='output_list', action='store_true',
@@ -4274,7 +4284,6 @@ class Archiver:
         subparser.add_argument('--tar-format', metavar='FMT', dest='tar_format', default='GNU',
                                choices=('BORG', 'PAX', 'GNU'),
                                help='select tar format: BORG, PAX or GNU')
-        # archive name
         subparser.add_argument('tarfile', metavar='FILE',
                                help='output tar file. "-" to write to stdout instead.')
         subparser.add_argument('paths', metavar='PATH', nargs='*', type=str,
@@ -4312,6 +4321,8 @@ class Archiver:
                                           formatter_class=argparse.RawDescriptionHelpFormatter,
                                           help='extract archive contents')
         subparser.set_defaults(func=self.do_extract)
+        subparser.add_argument('--name', dest='name', metavar='NAME', type=NameSpec,
+                               help='specify the archive name')
         subparser.add_argument('--list', dest='output_list', action='store_true',
                                help='output verbose list of items (files, dirs, ...)')
         subparser.add_argument('-n', '--dry-run', dest='dry_run', action='store_true',
@@ -4332,7 +4343,6 @@ class Archiver:
                                help='write all extracted data to stdout')
         subparser.add_argument('--sparse', dest='sparse', action='store_true',
                                help='create holes in output sparse file from all-zero chunks')
-        # archive name
         subparser.add_argument('paths', metavar='PATH', nargs='*', type=str,
                                help='paths to extract; patterns are supported')
         define_exclusion_group(subparser, strip_components=True)
@@ -4370,7 +4380,8 @@ class Archiver:
                                           formatter_class=argparse.RawDescriptionHelpFormatter,
                                           help='show repository or archive information')
         subparser.set_defaults(func=self.do_info)
-        # archive name
+        subparser.add_argument('--name', dest='name', metavar='NAME', type=NameSpec,
+                               help='specify the archive name')
         subparser.add_argument('--json', action='store_true',
                                help='format output as JSON')
         define_archive_filters_group(subparser)
@@ -4759,7 +4770,8 @@ class Archiver:
                                     'but keys used in it are added to the JSON output. '
                                     'Some keys are always present. Note: JSON can only represent text. '
                                     'A "bpath" key is therefore not available.')
-        # archive name
+        subparser.add_argument('--name', dest='name', metavar='NAME', type=NameSpec,
+                               help='specify the archive name')
         subparser.add_argument('paths', metavar='PATH', nargs='*', type=str,
                                help='paths to list; patterns are supported')
         define_archive_filters_group(subparser)
@@ -4969,7 +4981,8 @@ class Archiver:
                                         'HASH_MASK_BITS, HASH_WINDOW_SIZE) or `default` to use the current defaults. '
                                         'default: %s,%d,%d,%d,%d' % CHUNKER_PARAMS)
 
-        # archive name
+        subparser.add_argument('--name', dest='name', metavar='NAME', type=NameSpec,
+                               help='specify the archive name')
         subparser.add_argument('paths', metavar='PATH', nargs='*', type=str,
                                help='paths to recreate; patterns are supported')
 
@@ -4985,10 +4998,10 @@ class Archiver:
                                           formatter_class=argparse.RawDescriptionHelpFormatter,
                                           help='rename archive')
         subparser.set_defaults(func=self.do_rename)
-        subparser.add_argument('name_current', metavar='OLDNAME',
+        subparser.add_argument('--name', metavar='OLDNAME',
                                type=archivename_validator(),
                                help='the current archive name')
-        subparser.add_argument('name', metavar='NEWNAME',
+        subparser.add_argument('--name2', metavar='NEWNAME',
                                type=archivename_validator(),
                                help='the new archive name')
 
@@ -5211,7 +5224,8 @@ class Archiver:
                                    help='select compression algorithm, see the output of the '
                                         '"borg help compression" command for details.')
 
-        # archive name
+        subparser.add_argument('--name', dest='name', metavar='NAME', type=NameSpec,
+                               help='specify the archive name')
         subparser.add_argument('tarfile', metavar='TARFILE',
                                help='input tar file. "-" to read from stdin instead.')
         return parser
diff --git a/src/borg/fuse.py b/src/borg/fuse.py
index 5c9f8b935..5203a2959 100644
--- a/src/borg/fuse.py
+++ b/src/borg/fuse.py
@@ -272,11 +272,11 @@ class FuseBackend:
 
     def _create_filesystem(self):
         self._create_dir(parent=1)  # first call, create root dir (inode == 1)
-        if self._args.location.archive:
+        if self._args.name:
             if self.versions:
                 raise Error("for versions view, do not specify a single archive, "
                             "but always give the repository as location.")
-            self._process_archive(self._args.location.archive)
+            self._process_archive(self._args.name)
         else:
             self.versions_index = FuseVersionsIndex()
             for archive in self._manifest.archives.list_considering(self._args):
diff --git a/src/borg/helpers/manifest.py b/src/borg/helpers/manifest.py
index 1b9d91fb4..587176b49 100644
--- a/src/borg/helpers/manifest.py
+++ b/src/borg/helpers/manifest.py
@@ -103,7 +103,7 @@ class Archives(abc.MutableMapping):
         """
         get a list of archives, considering --first/last/prefix/glob-archives/sort/consider-checkpoints cmdline args
         """
-        if args.location.archive:
+        if args.name:
             raise Error('The options --first, --last, --prefix, and --glob-archives, and --consider-checkpoints can only be used on repository targets.')
         if args.prefix is not None:
             args.glob_archives = args.prefix + '*'
diff --git a/src/borg/helpers/parseformat.py b/src/borg/helpers/parseformat.py
index 7c25437b0..ab420dea7 100644
--- a/src/borg/helpers/parseformat.py
+++ b/src/borg/helpers/parseformat.py
@@ -213,6 +213,8 @@ PrefixSpec = replace_placeholders
 
 GlobSpec = replace_placeholders
 
+NameSpec = replace_placeholders
+
 CommentSpec = replace_placeholders
 
 
diff --git a/src/borg/testsuite/archiver.py b/src/borg/testsuite/archiver.py
index 1c67a5573..a22eebe4a 100644
--- a/src/borg/testsuite/archiver.py
+++ b/src/borg/testsuite/archiver.py
@@ -149,14 +149,14 @@ def test_return_codes(cmd, tmpdir):
     input.join('test_file').write('content')
     rc, out = cmd('--repo=%s' % str(repo), 'init', '--encryption=none')
     assert rc == EXIT_SUCCESS
-    rc, out = cmd('--repo=%s::archive' % repo, 'create', str(input))
+    rc, out = cmd('--repo=%s' % repo, 'create', '--name=archive', str(input))
     assert rc == EXIT_SUCCESS
     with changedir(str(output)):
-        rc, out = cmd('--repo=%s::archive' % repo, 'extract')
+        rc, out = cmd('--repo=%s' % repo, 'extract', '--name=archive')
         assert rc == EXIT_SUCCESS
-    rc, out = cmd('--repo=%s::archive' % repo, 'extract', 'does/not/match')
+    rc, out = cmd('--repo=%s' % repo, 'extract', '--name=archive', 'does/not/match')
     assert rc == EXIT_WARNING  # pattern did not match
-    rc, out = cmd('--repo=%s::archive' % repo, 'create', str(input))
+    rc, out = cmd('--repo=%s' % repo, 'create', '--name=archive', str(input))
     assert rc == EXIT_ERROR  # duplicate archive name
 
 
@@ -219,7 +219,7 @@ def test_disk_full(cmd):
                             break
                         raise
                     try:
-                        rc, out = cmd('--repo=%s::test%03d' % (repo, i), 'create', input)
+                        rc, out = cmd('--repo=%s' % repo, 'create', '--name=test%03d' % i, input)
                         success = rc == EXIT_SUCCESS
                         if not success:
                             print('create', rc, out)
@@ -299,7 +299,7 @@ class ArchiverTestCaseBase(BaseTestCase):
         return output
 
     def create_src_archive(self, name):
-        self.cmd(f'--repo={self.repository_location}::{name}', 'create', '--compression=lz4', src_dir)
+        self.cmd(f'--repo={self.repository_location}', 'create', f'--name={name}', '--compression=lz4', src_dir)
 
     def open_archive(self, name):
         repository = Repository(self.repository_path, exclusive=True)
@@ -394,12 +394,12 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         output = self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey', '--show-version', '--show-rc', fork=True)
         self.assert_in('borgbackup version', output)
         self.assert_in('terminating with success status, rc 0', output)
-        self.cmd(f'--repo={self.repository_location}::test', 'create', '--exclude-nodump', 'input')
-        output = self.cmd(f'--repo={self.repository_location}::test.2', 'create', '--exclude-nodump', '--stats', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', '--exclude-nodump', 'input')
+        output = self.cmd(f'--repo={self.repository_location}', 'create', '--name=test.2', '--exclude-nodump', '--stats', 'input')
         self.assert_in('Archive name: test.2', output)
         self.assert_in('This archive: ', output)
         with changedir('output'):
-            self.cmd(f'--repo={self.repository_location}::test', 'extract')
+            self.cmd(f'--repo={self.repository_location}', 'extract', '--name=test')
         list_output = self.cmd(f'--repo={self.repository_location}', 'list', '--short')
         self.assert_in('test', list_output)
         self.assert_in('test.2', list_output)
@@ -427,15 +427,15 @@ class ArchiverTestCase(ArchiverTestCaseBase):
             # remove the file we did not backup, so input and output become equal
             expected.remove('input/flagfile')  # this file is UF_NODUMP
             os.remove(os.path.join('input', 'flagfile'))
-        list_output = self.cmd(f'--repo={self.repository_location}::test', 'list', '--short')
+        list_output = self.cmd(f'--repo={self.repository_location}', 'list', '--name=test', '--short')
         for name in expected:
             self.assert_in(name, list_output)
         self.assert_dirs_equal('input', 'output/input')
-        info_output = self.cmd(f'--repo={self.repository_location}::test', 'info')
+        info_output = self.cmd(f'--repo={self.repository_location}', 'info', '--name=test')
         item_count = 5 if has_lchflags else 6  # one file is UF_NODUMP
         self.assert_in('Number of files: %d' % item_count, info_output)
         shutil.rmtree(self.cache_path)
-        info_output2 = self.cmd(f'--repo={self.repository_location}::test', 'info')
+        info_output2 = self.cmd(f'--repo={self.repository_location}', 'info', '--name=test')
 
         def filter(output):
             # filter for interesting "info" output, ignore cache rebuilding related stuff
@@ -463,9 +463,9 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self.create_regular_file(hl_a, contents=b'123456')
         os.link(hl_a, hl_b)
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=none')
-        self.cmd(f'--repo={self.repository_location}::test', 'create', 'input', 'input')  # give input twice!
+        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', 'input', 'input')  # give input twice!
         # test if created archive has 'input' contents twice:
-        archive_list = self.cmd(f'--repo={self.repository_location}::test', 'list', '--json-lines')
+        archive_list = self.cmd(f'--repo={self.repository_location}', 'list', '--name=test', '--json-lines')
         paths = [json.loads(line)['path'] for line in archive_list.split('\n') if line]
         # we have all fs items exactly once!
         assert sorted(paths) == ['input', 'input/a', 'input/a/hardlink', 'input/b', 'input/b/hardlink']
@@ -491,19 +491,19 @@ class ArchiverTestCase(ArchiverTestCaseBase):
                 pytest.skip('unix sockets disabled or not supported')
             elif err.errno == errno.EACCES:
                 pytest.skip('permission denied to create unix sockets')
-        self.cmd(f'--repo={self.repository_location}::test', 'create', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', 'input')
         sock.close()
         with changedir('output'):
-            self.cmd(f'--repo={self.repository_location}::test', 'extract')
+            self.cmd(f'--repo={self.repository_location}', 'extract', '--name=test')
             assert not os.path.exists('input/unix-socket')
 
     @pytest.mark.skipif(not are_symlinks_supported(), reason='symlinks not supported')
     def test_symlink_extract(self):
         self.create_test_files()
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
-        self.cmd(f'--repo={self.repository_location}::test', 'create', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', 'input')
         with changedir('output'):
-            self.cmd(f'--repo={self.repository_location}::test', 'extract')
+            self.cmd(f'--repo={self.repository_location}', 'extract', '--name=test')
             assert os.readlink('input/link1') == 'somewhere'
 
     @pytest.mark.skipif(not are_symlinks_supported() or not are_hardlinks_supported(),
@@ -514,9 +514,9 @@ class ArchiverTestCase(ArchiverTestCaseBase):
             os.symlink('target', 'symlink1')
             os.link('symlink1', 'symlink2', follow_symlinks=False)
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
-        self.cmd(f'--repo={self.repository_location}::test', 'create', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', 'input')
         with changedir('output'):
-            output = self.cmd(f'--repo={self.repository_location}::test', 'extract')
+            output = self.cmd(f'--repo={self.repository_location}', 'extract', '--name=test')
             print(output)
             with changedir('input'):
                 assert os.path.exists('target')
@@ -548,9 +548,9 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         have_noatime = has_noatime('input/file1')
         os.utime('input/file1', (atime, mtime))
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
-        self.cmd(f'--repo={self.repository_location}::test', 'create', '--atime', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', '--atime', 'input')
         with changedir('output'):
-            self.cmd(f'--repo={self.repository_location}::test', 'extract')
+            self.cmd(f'--repo={self.repository_location}', 'extract', '--name=test')
         sti = os.stat('input/file1')
         sto = os.stat('output/input/file1')
         assert sti.st_mtime_ns == sto.st_mtime_ns == mtime * 1e9
@@ -568,9 +568,9 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         os.utime('input/file1', (atime, birthtime))
         os.utime('input/file1', (atime, mtime))
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
-        self.cmd(f'--repo={self.repository_location}::test', 'create', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', 'input')
         with changedir('output'):
-            self.cmd(f'--repo={self.repository_location}::test', 'extract')
+            self.cmd(f'--repo={self.repository_location}', 'extract', '--name=test')
         sti = os.stat('input/file1')
         sto = os.stat('output/input/file1')
         assert int(sti.st_birthtime * 1e9) == int(sto.st_birthtime * 1e9) == birthtime * 1e9
@@ -584,9 +584,9 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         os.utime('input/file1', (atime, birthtime))
         os.utime('input/file1', (atime, mtime))
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
-        self.cmd(f'--repo={self.repository_location}::test', 'create', '--nobirthtime', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', '--nobirthtime', 'input')
         with changedir('output'):
-            self.cmd(f'--repo={self.repository_location}::test', 'extract')
+            self.cmd(f'--repo={self.repository_location}', 'extract', '--name=test')
         sti = os.stat('input/file1')
         sto = os.stat('output/input/file1')
         assert int(sti.st_birthtime * 1e9) == birthtime * 1e9
@@ -645,9 +645,9 @@ class ArchiverTestCase(ArchiverTestCaseBase):
             # we could create a sparse input file, so creating a backup of it and
             # extracting it again (as sparse) should also work:
             self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
-            self.cmd(f'--repo={self.repository_location}::test', 'create', 'input')
+            self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', 'input')
             with changedir(self.output_path):
-                self.cmd(f'--repo={self.repository_location}::test', 'extract', '--sparse')
+                self.cmd(f'--repo={self.repository_location}', 'extract', '--name=test', '--sparse')
             self.assert_dirs_equal('input', 'output/input')
             filename = os.path.join(self.output_path, 'input', 'sparse')
             with open(filename, 'rb') as fd:
@@ -664,10 +664,10 @@ class ArchiverTestCase(ArchiverTestCaseBase):
             with open(filename, 'wb'):
                 pass
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
-        self.cmd(f'--repo={self.repository_location}::test', 'create', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', 'input')
         for filename in filenames:
             with changedir('output'):
-                self.cmd(f'--repo={self.repository_location}::test', 'extract', os.path.join('input', filename))
+                self.cmd(f'--repo={self.repository_location}', 'extract', '--name=test', os.path.join('input', filename))
             assert os.path.exists(os.path.join('output', 'input', filename))
 
     def test_repository_swap_detection(self):
@@ -675,70 +675,70 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         os.environ['BORG_PASSPHRASE'] = 'passphrase'
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
         repository_id = self._extract_repository_id(self.repository_path)
-        self.cmd(f'--repo={self.repository_location}::test', 'create', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', 'input')
         shutil.rmtree(self.repository_path)
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=none')
         self._set_repository_id(self.repository_path, repository_id)
         self.assert_equal(repository_id, self._extract_repository_id(self.repository_path))
         if self.FORK_DEFAULT:
-            self.cmd(f'--repo={self.repository_location}::test.2', 'create', 'input', exit_code=EXIT_ERROR)
+            self.cmd(f'--repo={self.repository_location}', 'create', '--name=test.2', 'input', exit_code=EXIT_ERROR)
         else:
             with pytest.raises(Cache.EncryptionMethodMismatch):
-                self.cmd(f'--repo={self.repository_location}::test.2', 'create', 'input')
+                self.cmd(f'--repo={self.repository_location}', 'create', '--name=test.2', 'input')
 
     def test_repository_swap_detection2(self):
         self.create_test_files()
         self.cmd(f'--repo={self.repository_location}_unencrypted', 'init', '--encryption=none')
         os.environ['BORG_PASSPHRASE'] = 'passphrase'
         self.cmd(f'--repo={self.repository_location}_encrypted', 'init', '--encryption=repokey')
-        self.cmd(f'--repo={self.repository_location}_encrypted::test', 'create', 'input')
+        self.cmd(f'--repo={self.repository_location}_encrypted', 'create', '--name=test', 'input')
         shutil.rmtree(self.repository_path + '_encrypted')
         os.rename(self.repository_path + '_unencrypted', self.repository_path + '_encrypted')
         if self.FORK_DEFAULT:
-            self.cmd(f'--repo={self.repository_location}_encrypted::test.2', 'create', 'input', exit_code=EXIT_ERROR)
+            self.cmd(f'--repo={self.repository_location}_encrypted', 'create', '--name=test.2', 'input', exit_code=EXIT_ERROR)
         else:
             with pytest.raises(Cache.RepositoryAccessAborted):
-                self.cmd(f'--repo={self.repository_location}_encrypted::test.2', 'create', 'input')
+                self.cmd(f'--repo={self.repository_location}_encrypted', 'create', '--name=test.2', 'input')
 
     def test_repository_swap_detection_no_cache(self):
         self.create_test_files()
         os.environ['BORG_PASSPHRASE'] = 'passphrase'
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
         repository_id = self._extract_repository_id(self.repository_path)
-        self.cmd(f'--repo={self.repository_location}::test', 'create', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', 'input')
         shutil.rmtree(self.repository_path)
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=none')
         self._set_repository_id(self.repository_path, repository_id)
         self.assert_equal(repository_id, self._extract_repository_id(self.repository_path))
         self.cmd(f'--repo={self.repository_location}', 'delete', '--cache-only')
         if self.FORK_DEFAULT:
-            self.cmd(f'--repo={self.repository_location}::test.2', 'create', 'input', exit_code=EXIT_ERROR)
+            self.cmd(f'--repo={self.repository_location}', 'create', '--name=test.2', 'input', exit_code=EXIT_ERROR)
         else:
             with pytest.raises(Cache.EncryptionMethodMismatch):
-                self.cmd(f'--repo={self.repository_location}::test.2', 'create', 'input')
+                self.cmd(f'--repo={self.repository_location}', 'create', '--name=test.2', 'input')
 
     def test_repository_swap_detection2_no_cache(self):
         self.create_test_files()
         self.cmd(f'--repo={self.repository_location}_unencrypted', 'init', '--encryption=none')
         os.environ['BORG_PASSPHRASE'] = 'passphrase'
         self.cmd(f'--repo={self.repository_location}_encrypted', 'init', '--encryption=repokey')
-        self.cmd(f'--repo={self.repository_location}_encrypted::test', 'create', 'input')
+        self.cmd(f'--repo={self.repository_location}_encrypted', 'create', '--name=test', 'input')
         self.cmd(f'--repo={self.repository_location}_unencrypted', 'delete', '--cache-only')
         self.cmd(f'--repo={self.repository_location}_encrypted', 'delete', '--cache-only')
         shutil.rmtree(self.repository_path + '_encrypted')
         os.rename(self.repository_path + '_unencrypted', self.repository_path + '_encrypted')
         if self.FORK_DEFAULT:
-            self.cmd(f'--repo={self.repository_location}_encrypted::test.2', 'create', 'input', exit_code=EXIT_ERROR)
+            self.cmd(f'--repo={self.repository_location}_encrypted', 'create', '--name=test.2', 'input', exit_code=EXIT_ERROR)
         else:
             with pytest.raises(Cache.RepositoryAccessAborted):
-                self.cmd(f'--repo={self.repository_location}_encrypted::test.2', 'create', 'input')
+                self.cmd(f'--repo={self.repository_location}_encrypted', 'create', '--name=test.2', 'input')
 
     def test_repository_swap_detection_repokey_blank_passphrase(self):
         # Check that a repokey repo with a blank passphrase is considered like a plaintext repo.
         self.create_test_files()
         # User initializes her repository with her passphrase
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
-        self.cmd(f'--repo={self.repository_location}::test', 'create', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', 'input')
         # Attacker replaces it with her own repository, which is encrypted but has no passphrase set
         shutil.rmtree(self.repository_path)
         with environment_variable(BORG_PASSPHRASE=''):
@@ -751,10 +751,10 @@ class ArchiverTestCase(ArchiverTestCaseBase):
             # is set, while it isn't. Previously this raised no warning,
             # since the repository is, technically, encrypted.
             if self.FORK_DEFAULT:
-                self.cmd(f'--repo={self.repository_location}::test.2', 'create', 'input', exit_code=EXIT_ERROR)
+                self.cmd(f'--repo={self.repository_location}', 'create', '--name=test.2', 'input', exit_code=EXIT_ERROR)
             else:
                 with pytest.raises(Cache.CacheInitAbortedError):
-                    self.cmd(f'--repo={self.repository_location}::test.2', 'create', 'input')
+                    self.cmd(f'--repo={self.repository_location}', 'create', '--name=test.2', 'input')
 
     def test_repository_move(self):
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
@@ -805,16 +805,16 @@ class ArchiverTestCase(ArchiverTestCaseBase):
     def test_strip_components(self):
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
         self.create_regular_file('dir/file')
-        self.cmd(f'--repo={self.repository_location}::test', 'create', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', 'input')
         with changedir('output'):
-            self.cmd(f'--repo={self.repository_location}::test', 'extract', '--strip-components', '3')
+            self.cmd(f'--repo={self.repository_location}', 'extract', '--name=test', '--strip-components', '3')
             assert not os.path.exists('file')
             with self.assert_creates_file('file'):
-                self.cmd(f'--repo={self.repository_location}::test', 'extract', '--strip-components', '2')
+                self.cmd(f'--repo={self.repository_location}', 'extract', '--name=test', '--strip-components', '2')
             with self.assert_creates_file('dir/file'):
-                self.cmd(f'--repo={self.repository_location}::test', 'extract', '--strip-components', '1')
+                self.cmd(f'--repo={self.repository_location}', 'extract', '--name=test', '--strip-components', '1')
             with self.assert_creates_file('input/dir/file'):
-                self.cmd(f'--repo={self.repository_location}::test', 'extract', '--strip-components', '0')
+                self.cmd(f'--repo={self.repository_location}', 'extract', '--name=test', '--strip-components', '0')
 
     def _extract_hardlinks_setup(self):
         os.mkdir(os.path.join(self.input_path, 'dir1'))
@@ -833,7 +833,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
                 os.path.join(self.input_path, 'dir1/aaaa'))
 
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
-        self.cmd(f'--repo={self.repository_location}::test', 'create', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', 'input')
 
     @requires_hardlinks
     @unittest.skipUnless(llfuse, 'llfuse not installed')
@@ -847,21 +847,21 @@ class ArchiverTestCase(ArchiverTestCaseBase):
             ignore_perms = ['-o', 'ignore_permissions,defer_permissions']
         else:
             ignore_perms = ['-o', 'ignore_permissions']
-        with self.fuse_mount(self.repository_location + '::test', mountpoint, '--strip-components=2', *ignore_perms), \
+        with self.fuse_mount(self.repository_location, mountpoint, '--name=test', '--strip-components=2', *ignore_perms), \
              changedir(mountpoint):
             assert os.stat('hardlink').st_nlink == 2
             assert os.stat('subdir/hardlink').st_nlink == 2
             assert open('subdir/hardlink', 'rb').read() == b'123456'
             assert os.stat('aaaa').st_nlink == 2
             assert os.stat('source2').st_nlink == 2
-        with self.fuse_mount(self.repository_location + '::test', mountpoint, 'input/dir1', *ignore_perms), \
+        with self.fuse_mount(self.repository_location, mountpoint, 'input/dir1', '--name=test', *ignore_perms), \
              changedir(mountpoint):
             assert os.stat('input/dir1/hardlink').st_nlink == 2
             assert os.stat('input/dir1/subdir/hardlink').st_nlink == 2
             assert open('input/dir1/subdir/hardlink', 'rb').read() == b'123456'
             assert os.stat('input/dir1/aaaa').st_nlink == 2
             assert os.stat('input/dir1/source2').st_nlink == 2
-        with self.fuse_mount(self.repository_location + '::test', mountpoint, *ignore_perms), \
+        with self.fuse_mount(self.repository_location, mountpoint, '--name=test', *ignore_perms), \
              changedir(mountpoint):
             assert os.stat('input/source').st_nlink == 4
             assert os.stat('input/abba').st_nlink == 4
@@ -873,7 +873,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
     def test_extract_hardlinks1(self):
         self._extract_hardlinks_setup()
         with changedir('output'):
-            self.cmd(f'--repo={self.repository_location}::test', 'extract')
+            self.cmd(f'--repo={self.repository_location}', 'extract', '--name=test')
             assert os.stat('input/source').st_nlink == 4
             assert os.stat('input/abba').st_nlink == 4
             assert os.stat('input/dir1/hardlink').st_nlink == 4
@@ -884,14 +884,14 @@ class ArchiverTestCase(ArchiverTestCaseBase):
     def test_extract_hardlinks2(self):
         self._extract_hardlinks_setup()
         with changedir('output'):
-            self.cmd(f'--repo={self.repository_location}::test', 'extract', '--strip-components', '2')
+            self.cmd(f'--repo={self.repository_location}', 'extract', '--name=test', '--strip-components', '2')
             assert os.stat('hardlink').st_nlink == 2
             assert os.stat('subdir/hardlink').st_nlink == 2
             assert open('subdir/hardlink', 'rb').read() == b'123456'
             assert os.stat('aaaa').st_nlink == 2
             assert os.stat('source2').st_nlink == 2
         with changedir('output'):
-            self.cmd(f'--repo={self.repository_location}::test', 'extract', 'input/dir1')
+            self.cmd(f'--repo={self.repository_location}', 'extract', '--name=test', 'input/dir1')
             assert os.stat('input/dir1/hardlink').st_nlink == 2
             assert os.stat('input/dir1/subdir/hardlink').st_nlink == 2
             assert open('input/dir1/subdir/hardlink', 'rb').read() == b'123456'
@@ -910,10 +910,10 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self.create_regular_file(hl_a, contents=b'123456')
         os.link(hl_a, hl_b)
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=none')
-        self.cmd(f'--repo={self.repository_location}::test', 'create', 'input', 'input')  # give input twice!
+        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', 'input', 'input')  # give input twice!
         # now test extraction
         with changedir('output'):
-            self.cmd(f'--repo={self.repository_location}::test', 'extract')
+            self.cmd(f'--repo={self.repository_location}', 'extract', '--name=test')
             # if issue #5603 happens, extraction gives rc == 1 (triggering AssertionError) and warnings like:
             # input/a/hardlink: link: [Errno 2] No such file or directory: 'input/a/hardlink' -> 'input/a/hardlink'
             # input/b/hardlink: link: [Errno 2] No such file or directory: 'input/a/hardlink' -> 'input/b/hardlink'
@@ -927,15 +927,15 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self.create_regular_file('file2', size=1024 * 80)
         self.create_regular_file('file3', size=1024 * 80)
         self.create_regular_file('file4', size=1024 * 80)
-        self.cmd(f'--repo={self.repository_location}::test', 'create', '--exclude=input/file4', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', '--exclude=input/file4', 'input')
         with changedir('output'):
-            self.cmd(f'--repo={self.repository_location}::test', 'extract', 'input/file1', )
+            self.cmd(f'--repo={self.repository_location}', 'extract', '--name=test', 'input/file1', )
         self.assert_equal(sorted(os.listdir('output/input')), ['file1'])
         with changedir('output'):
-            self.cmd(f'--repo={self.repository_location}::test', 'extract', '--exclude=input/file2')
+            self.cmd(f'--repo={self.repository_location}', 'extract', '--name=test', '--exclude=input/file2')
         self.assert_equal(sorted(os.listdir('output/input')), ['file1', 'file3'])
         with changedir('output'):
-            self.cmd(f'--repo={self.repository_location}::test', 'extract', '--exclude-from=' + self.exclude_file_path)
+            self.cmd(f'--repo={self.repository_location}', 'extract', '--name=test', '--exclude-from=' + self.exclude_file_path)
         self.assert_equal(sorted(os.listdir('output/input')), ['file1', 'file3'])
 
     def test_extract_include_exclude_regex(self):
@@ -947,27 +947,27 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self.create_regular_file('file333', size=1024 * 80)
 
         # Create with regular expression exclusion for file4
-        self.cmd(f'--repo={self.repository_location}::test', 'create', '--exclude=re:input/file4$', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', '--exclude=re:input/file4$', 'input')
         with changedir('output'):
-            self.cmd(f'--repo={self.repository_location}::test', 'extract')
+            self.cmd(f'--repo={self.repository_location}', 'extract', '--name=test')
         self.assert_equal(sorted(os.listdir('output/input')), ['file1', 'file2', 'file3', 'file333'])
         shutil.rmtree('output/input')
 
         # Extract with regular expression exclusion
         with changedir('output'):
-            self.cmd(f'--repo={self.repository_location}::test', 'extract', '--exclude=re:file3+')
+            self.cmd(f'--repo={self.repository_location}', 'extract', '--name=test', '--exclude=re:file3+')
         self.assert_equal(sorted(os.listdir('output/input')), ['file1', 'file2'])
         shutil.rmtree('output/input')
 
         # Combine --exclude with fnmatch and regular expression
         with changedir('output'):
-            self.cmd(f'--repo={self.repository_location}::test', 'extract', '--exclude=input/file2', '--exclude=re:file[01]')
+            self.cmd(f'--repo={self.repository_location}', 'extract', '--name=test', '--exclude=input/file2', '--exclude=re:file[01]')
         self.assert_equal(sorted(os.listdir('output/input')), ['file3', 'file333'])
         shutil.rmtree('output/input')
 
         # Combine --exclude-from and regular expression exclusion
         with changedir('output'):
-            self.cmd(f'--repo={self.repository_location}::test', 'extract', '--exclude-from=' + self.exclude_file_path,
+            self.cmd(f'--repo={self.repository_location}', 'extract', '--name=test', '--exclude-from=' + self.exclude_file_path,
                      '--exclude=re:file1', '--exclude=re:file(\\d)\\1\\1$')
         self.assert_equal(sorted(os.listdir('output/input')), ['file3'])
 
@@ -985,9 +985,9 @@ class ArchiverTestCase(ArchiverTestCaseBase):
             fd.write(b're:input/file4$\n')
             fd.write(b'fm:*aa:*thing\n')
 
-        self.cmd(f'--repo={self.repository_location}::test', 'create', '--exclude-from=' + self.exclude_file_path, 'input')
+        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', '--exclude-from=' + self.exclude_file_path, 'input')
         with changedir('output'):
-            self.cmd(f'--repo={self.repository_location}::test', 'extract')
+            self.cmd(f'--repo={self.repository_location}', 'extract', '--name=test')
         self.assert_equal(sorted(os.listdir('output/input')), ['file1', 'file2', 'file3', 'file333'])
         shutil.rmtree('output/input')
 
@@ -996,7 +996,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
             fd.write(b're:file3+\n')
 
         with changedir('output'):
-            self.cmd(f'--repo={self.repository_location}::test', 'extract', '--exclude-from=' + self.exclude_file_path)
+            self.cmd(f'--repo={self.repository_location}', 'extract', '--name=test', '--exclude-from=' + self.exclude_file_path)
         self.assert_equal(sorted(os.listdir('output/input')), ['file1', 'file2'])
         shutil.rmtree('output/input')
 
@@ -1008,7 +1008,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
             fd.write(b're:file2$\n')
 
         with changedir('output'):
-            self.cmd(f'--repo={self.repository_location}::test', 'extract', '--exclude-from=' + self.exclude_file_path)
+            self.cmd(f'--repo={self.repository_location}', 'extract', '--name=test', '--exclude-from=' + self.exclude_file_path)
         self.assert_equal(sorted(os.listdir('output/input')), ['file3'])
 
     def test_extract_with_pattern(self):
@@ -1019,63 +1019,63 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self.create_regular_file("file4", size=1024 * 80)
         self.create_regular_file("file333", size=1024 * 80)
 
-        self.cmd(f'--repo={self.repository_location}::test', "create", "input")
+        self.cmd(f'--repo={self.repository_location}', "create", "--name=test", "input")
 
         # Extract everything with regular expression
         with changedir("output"):
-            self.cmd(f'--repo={self.repository_location}::test', "extract", "re:.*")
+            self.cmd(f'--repo={self.repository_location}', "extract", "--name=test", "re:.*")
         self.assert_equal(sorted(os.listdir("output/input")), ["file1", "file2", "file3", "file333", "file4"])
         shutil.rmtree("output/input")
 
         # Extract with pattern while also excluding files
         with changedir("output"):
-            self.cmd(f'--repo={self.repository_location}::test', "extract", "--exclude=re:file[34]$", r"re:file\d$")
+            self.cmd(f'--repo={self.repository_location}', "extract", "--name=test", "--exclude=re:file[34]$", r"re:file\d$")
         self.assert_equal(sorted(os.listdir("output/input")), ["file1", "file2"])
         shutil.rmtree("output/input")
 
         # Combine --exclude with pattern for extraction
         with changedir("output"):
-            self.cmd(f'--repo={self.repository_location}::test', "extract", "--exclude=input/file1", "re:file[12]$")
+            self.cmd(f'--repo={self.repository_location}', "extract", "--name=test", "--exclude=input/file1", "re:file[12]$")
         self.assert_equal(sorted(os.listdir("output/input")), ["file2"])
         shutil.rmtree("output/input")
 
         # Multiple pattern
         with changedir("output"):
-            self.cmd(f'--repo={self.repository_location}::test', "extract", "fm:input/file1", "fm:*file33*", "input/file2")
+            self.cmd(f'--repo={self.repository_location}', "extract", "--name=test", "fm:input/file1", "fm:*file33*", "input/file2")
         self.assert_equal(sorted(os.listdir("output/input")), ["file1", "file2", "file333"])
 
     def test_extract_list_output(self):
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
         self.create_regular_file('file', size=1024 * 80)
 
-        self.cmd(f'--repo={self.repository_location}::test', 'create', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', 'input')
 
         with changedir('output'):
-            output = self.cmd(f'--repo={self.repository_location}::test', 'extract')
+            output = self.cmd(f'--repo={self.repository_location}', 'extract', '--name=test')
         self.assert_not_in("input/file", output)
         shutil.rmtree('output/input')
 
         with changedir('output'):
-            output = self.cmd(f'--repo={self.repository_location}::test', 'extract', '--info')
+            output = self.cmd(f'--repo={self.repository_location}', 'extract', '--name=test', '--info')
         self.assert_not_in("input/file", output)
         shutil.rmtree('output/input')
 
         with changedir('output'):
-            output = self.cmd(f'--repo={self.repository_location}::test', 'extract', '--list')
+            output = self.cmd(f'--repo={self.repository_location}', 'extract', '--name=test', '--list')
         self.assert_in("input/file", output)
         shutil.rmtree('output/input')
 
         with changedir('output'):
-            output = self.cmd(f'--repo={self.repository_location}::test', 'extract', '--list', '--info')
+            output = self.cmd(f'--repo={self.repository_location}', 'extract', '--name=test', '--list', '--info')
         self.assert_in("input/file", output)
 
     def test_extract_progress(self):
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
         self.create_regular_file('file', size=1024 * 80)
-        self.cmd(f'--repo={self.repository_location}::test', 'create', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', 'input')
 
         with changedir('output'):
-            output = self.cmd(f'--repo={self.repository_location}::test', 'extract', '--progress')
+            output = self.cmd(f'--repo={self.repository_location}', 'extract', '--name=test', '--progress')
             assert 'Extracting:' in output
 
     def _create_test_caches(self):
@@ -1095,32 +1095,32 @@ class ArchiverTestCase(ArchiverTestCaseBase):
     def test_create_stdin(self):
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
         input_data = b'\x00foo\n\nbar\n   \n'
-        self.cmd(f'--repo={self.repository_location}::test', 'create', '-', input=input_data)
-        item = json.loads(self.cmd(f'--repo={self.repository_location}::test', 'list', '--json-lines'))
+        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', '-', input=input_data)
+        item = json.loads(self.cmd(f'--repo={self.repository_location}', 'list', '--name=test', '--json-lines'))
         assert item['uid'] == 0
         assert item['gid'] == 0
         assert item['size'] == len(input_data)
         assert item['path'] == 'stdin'
-        extracted_data = self.cmd(f'--repo={self.repository_location}::test', 'extract', '--stdout', binary_output=True)
+        extracted_data = self.cmd(f'--repo={self.repository_location}', 'extract', '--name=test', '--stdout', binary_output=True)
         assert extracted_data == input_data
 
     def test_create_content_from_command(self):
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
         input_data = 'some test content'
         name = 'a/b/c'
-        self.cmd(f'--repo={self.repository_location}::test', 'create', '--stdin-name', name, '--content-from-command',
+        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', '--stdin-name', name, '--content-from-command',
                  '--', 'echo', input_data)
-        item = json.loads(self.cmd(f'--repo={self.repository_location}::test', 'list', '--json-lines'))
+        item = json.loads(self.cmd(f'--repo={self.repository_location}', 'list', '--name=test', '--json-lines'))
         assert item['uid'] == 0
         assert item['gid'] == 0
         assert item['size'] == len(input_data) + 1  # `echo` adds newline
         assert item['path'] == name
-        extracted_data = self.cmd(f'--repo={self.repository_location}::test', 'extract', '--stdout')
+        extracted_data = self.cmd(f'--repo={self.repository_location}', 'extract', '--name=test', '--stdout')
         assert extracted_data == input_data + '\n'
 
     def test_create_content_from_command_with_failed_command(self):
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
-        output = self.cmd(f'--repo={self.repository_location}::test', 'create', '--content-from-command',
+        output = self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', '--content-from-command',
                           '--', 'sh', '-c', 'exit 73;', exit_code=2)
         assert output.endswith("Command 'sh' exited with status 73\n")
         archive_list = json.loads(self.cmd(f'--repo={self.repository_location}', 'list', '--json'))
@@ -1128,7 +1128,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
 
     def test_create_content_from_command_missing_command(self):
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
-        output = self.cmd(f'--repo={self.repository_location}::test', 'create', '--content-from-command', exit_code=2)
+        output = self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', '--content-from-command', exit_code=2)
         assert output.endswith('No command given.\n')
 
     def test_create_paths_from_stdin(self):
@@ -1139,9 +1139,9 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self.create_regular_file("file4", size=1024 * 80)
 
         input_data = b'input/file1\0input/dir1\0input/file4'
-        self.cmd(f'--repo={self.repository_location}::test', 'create',
+        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test',
                  '--paths-from-stdin', '--paths-delimiter', '\\0', input=input_data)
-        archive_list = self.cmd(f'--repo={self.repository_location}::test', 'list', '--json-lines')
+        archive_list = self.cmd(f'--repo={self.repository_location}', 'list', '--name=test', '--json-lines')
         paths = [json.loads(line)['path'] for line in archive_list.split('\n') if line]
         assert paths == ['input/file1', 'input/dir1', 'input/file4']
 
@@ -1153,15 +1153,15 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self.create_regular_file("file4", size=1024 * 80)
 
         input_data = 'input/file1\ninput/file2\ninput/file3'
-        self.cmd(f'--repo={self.repository_location}::test', 'create', '--paths-from-command',
+        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', '--paths-from-command',
                  '--', 'echo', input_data)
-        archive_list = self.cmd(f'--repo={self.repository_location}::test', 'list', '--json-lines')
+        archive_list = self.cmd(f'--repo={self.repository_location}', 'list', '--name=test', '--json-lines')
         paths = [json.loads(line)['path'] for line in archive_list.split('\n') if line]
         assert paths == ['input/file1', 'input/file2', 'input/file3']
 
     def test_create_paths_from_command_with_failed_command(self):
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
-        output = self.cmd(f'--repo={self.repository_location}::test', 'create', '--paths-from-command',
+        output = self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', '--paths-from-command',
                           '--', 'sh', '-c', 'exit 73;', exit_code=2)
         assert output.endswith("Command 'sh' exited with status 73\n")
         archive_list = json.loads(self.cmd(f'--repo={self.repository_location}', 'list', '--json'))
@@ -1169,20 +1169,20 @@ class ArchiverTestCase(ArchiverTestCaseBase):
 
     def test_create_paths_from_command_missing_command(self):
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
-        output = self.cmd(f'--repo={self.repository_location}::test', 'create', '--paths-from-command', exit_code=2)
+        output = self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', '--paths-from-command', exit_code=2)
         assert output.endswith('No command given.\n')
 
     def test_create_without_root(self):
         """test create without a root"""
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
-        self.cmd(f'--repo={self.repository_location}::test', 'create', exit_code=2)
+        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', exit_code=2)
 
     def test_create_pattern_root(self):
         """test create with only a root pattern"""
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
         self.create_regular_file('file1', size=1024 * 80)
         self.create_regular_file('file2', size=1024 * 80)
-        output = self.cmd(f'--repo={self.repository_location}::test', 'create', '-v', '--list', '--pattern=R input')
+        output = self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', '-v', '--list', '--pattern=R input')
         self.assert_in("A input/file1", output)
         self.assert_in("A input/file2", output)
 
@@ -1192,7 +1192,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self.create_regular_file('file1', size=1024 * 80)
         self.create_regular_file('file2', size=1024 * 80)
         self.create_regular_file('file_important', size=1024 * 80)
-        output = self.cmd(f'--repo={self.repository_location}::test', 'create', '-v', '--list',
+        output = self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', '-v', '--list',
                           '--pattern=+input/file_important', '--pattern=-input/file*',
                           'input')
         self.assert_in("A input/file_important", output)
@@ -1206,7 +1206,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self.create_regular_file('file2', size=1024 * 80)
         self.create_regular_file('otherfile', size=1024 * 80)
         self.create_regular_file('file_important', size=1024 * 80)
-        output = self.cmd(f'--repo={self.repository_location}::test', 'create', '-v', '--list',
+        output = self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', '-v', '--list',
                           '--pattern=-input/otherfile', '--patterns-from=' + self.patterns_file_path,
                           'input')
         self.assert_in("A input/file_important", output)
@@ -1224,7 +1224,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self.create_regular_file('x/a/foo_a', size=1024 * 80)
         self.create_regular_file('x/b/foo_b', size=1024 * 80)
         self.create_regular_file('y/foo_y', size=1024 * 80)
-        output = self.cmd(f'--repo={self.repository_location}::test', 'create', '-v', '--list',
+        output = self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', '-v', '--list',
                           '--patterns-from=' + self.patterns_file_path2,
                           'input')
         self.assert_in('x input/x/a/foo_a', output)
@@ -1241,7 +1241,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self.create_regular_file('x/a/foo_a', size=1024 * 80)
         self.create_regular_file('x/b/foo_b', size=1024 * 80)
         self.create_regular_file('y/foo_y', size=1024 * 80)
-        output = self.cmd(f'--repo={self.repository_location}::test', 'create', '-v', '--list',
+        output = self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', '-v', '--list',
                           '--patterns-from=' + self.patterns_file_path2,
                           'input')
         self.assert_not_in('input/x/a/foo_a', output)
@@ -1259,12 +1259,12 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self.create_regular_file('x/a/foo_a', size=1024 * 80)
         self.create_regular_file('x/b/foo_b', size=1024 * 80)
         with changedir('input'):
-            self.cmd(f'--repo={self.repository_location}::test', 'create', '--patterns-from=' + self.patterns_file_path2,
-                     '.')
+            self.cmd(f'--repo={self.repository_location}', 'create', '--name=test',
+                     '--patterns-from=' + self.patterns_file_path2, '.')
 
         # list the archive and verify that the "intermediate" folders appear before
         # their contents
-        out = self.cmd(f'--repo={self.repository_location}::test', 'list', '--format', '{type} {path}{NL}')
+        out = self.cmd(f'--repo={self.repository_location}', 'list', '--name=test', '--format', '{type} {path}{NL}')
         out_list = out.splitlines()
 
         self.assert_in('d x/a', out_list)
@@ -1277,14 +1277,15 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self.create_test_files()
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
         self.cmd(f'--repo={self.repository_location}', 'delete', '--cache-only')
-        create_json = json.loads(self.cmd(f'--repo={self.repository_location}::test', 'create', '--no-cache-sync', 'input',
+        create_json = json.loads(self.cmd(f'--repo={self.repository_location}', 'create', '--name=test',
+                                          '--no-cache-sync', 'input',
                                           '--json', '--error'))  # ignore experimental warning
-        info_json = json.loads(self.cmd(f'--repo={self.repository_location}::test', 'info', '--json'))
+        info_json = json.loads(self.cmd(f'--repo={self.repository_location}', 'info', '--name=test', '--json'))
         create_stats = create_json['cache']['stats']
         info_stats = info_json['cache']['stats']
         assert create_stats == info_stats
         self.cmd(f'--repo={self.repository_location}', 'delete', '--cache-only')
-        self.cmd(f'--repo={self.repository_location}::test2', 'create', '--no-cache-sync', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test2', '--no-cache-sync', 'input')
         self.cmd(f'--repo={self.repository_location}', 'info')
         self.cmd(f'--repo={self.repository_location}', 'check')
 
@@ -1293,27 +1294,27 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self.create_regular_file('file1', size=1024 * 80)
         self.create_regular_file('file2', size=1024 * 80)
         self.create_regular_file('file_important', size=1024 * 80)
-        self.cmd(f'--repo={self.repository_location}::test', 'create', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', 'input')
         with changedir('output'):
-            self.cmd(f'--repo={self.repository_location}::test', 'extract',
+            self.cmd(f'--repo={self.repository_location}', 'extract', '--name=test',
                      '--pattern=+input/file_important', '--pattern=-input/file*')
         self.assert_equal(sorted(os.listdir('output/input')), ['file_important'])
 
     def _assert_test_caches(self):
         with changedir('output'):
-            self.cmd(f'--repo={self.repository_location}::test', 'extract')
+            self.cmd(f'--repo={self.repository_location}', 'extract', '--name=test')
         self.assert_equal(sorted(os.listdir('output/input')), ['cache2', 'file1'])
         self.assert_equal(sorted(os.listdir('output/input/cache2')), [CACHE_TAG_NAME])
 
     def test_exclude_caches(self):
         self._create_test_caches()
-        self.cmd(f'--repo={self.repository_location}::test', 'create', '--exclude-caches', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', '--exclude-caches', 'input')
         self._assert_test_caches()
 
     def test_recreate_exclude_caches(self):
         self._create_test_caches()
-        self.cmd(f'--repo={self.repository_location}::test', 'create', 'input')
-        self.cmd(f'--repo={self.repository_location}::test', 'recreate', '--exclude-caches')
+        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'recreate', '--name=test', '--exclude-caches')
         self._assert_test_caches()
 
     def _create_test_tagged(self):
@@ -1325,19 +1326,19 @@ class ArchiverTestCase(ArchiverTestCaseBase):
 
     def _assert_test_tagged(self):
         with changedir('output'):
-            self.cmd(f'--repo={self.repository_location}::test', 'extract')
+            self.cmd(f'--repo={self.repository_location}', 'extract', '--name=test')
         self.assert_equal(sorted(os.listdir('output/input')), ['file1'])
 
     def test_exclude_tagged(self):
         self._create_test_tagged()
-        self.cmd(f'--repo={self.repository_location}::test', 'create', '--exclude-if-present', '.NOBACKUP',
+        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', '--exclude-if-present', '.NOBACKUP',
                  '--exclude-if-present', '00-NOBACKUP', 'input')
         self._assert_test_tagged()
 
     def test_recreate_exclude_tagged(self):
         self._create_test_tagged()
-        self.cmd(f'--repo={self.repository_location}::test', 'create', 'input')
-        self.cmd(f'--repo={self.repository_location}::test', 'recreate', '--exclude-if-present', '.NOBACKUP',
+        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'recreate', '--name=test', '--exclude-if-present', '.NOBACKUP',
                  '--exclude-if-present', '00-NOBACKUP')
         self._assert_test_tagged()
 
@@ -1359,7 +1360,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
 
     def _assert_test_keep_tagged(self):
         with changedir('output'):
-            self.cmd(f'--repo={self.repository_location}::test', 'extract')
+            self.cmd(f'--repo={self.repository_location}', 'extract', '--name=test')
         self.assert_equal(sorted(os.listdir('output/input')), ['file0', 'tagged1', 'tagged2', 'tagged3', 'taggedall'])
         self.assert_equal(os.listdir('output/input/tagged1'), ['.NOBACKUP1'])
         self.assert_equal(os.listdir('output/input/tagged2'), ['.NOBACKUP2'])
@@ -1369,14 +1370,14 @@ class ArchiverTestCase(ArchiverTestCaseBase):
 
     def test_exclude_keep_tagged(self):
         self._create_test_keep_tagged()
-        self.cmd(f'--repo={self.repository_location}::test', 'create', '--exclude-if-present', '.NOBACKUP1',
+        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', '--exclude-if-present', '.NOBACKUP1',
                  '--exclude-if-present', '.NOBACKUP2', '--exclude-caches', '--keep-exclude-tags', 'input')
         self._assert_test_keep_tagged()
 
     def test_recreate_exclude_keep_tagged(self):
         self._create_test_keep_tagged()
-        self.cmd(f'--repo={self.repository_location}::test', 'create', 'input')
-        self.cmd(f'--repo={self.repository_location}::test', 'recreate', '--exclude-if-present', '.NOBACKUP1',
+        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'recreate', '--name=test', '--exclude-if-present', '.NOBACKUP1',
                  '--exclude-if-present', '.NOBACKUP2', '--exclude-caches', '--keep-exclude-tags')
         self._assert_test_keep_tagged()
 
@@ -1387,11 +1388,11 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         os.mkdir(os.path.join(self.input_path, 'subdir'))  # to make sure the tag is encountered *after* file1
         os.link(os.path.join(self.input_path, 'file1'),
                 os.path.join(self.input_path, 'subdir', CACHE_TAG_NAME))  # correct tag name, hardlink to file1
-        self.cmd(f'--repo={self.repository_location}::test', 'create', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', 'input')
         # in the "test" archive, we now have, in this order:
         # - a regular file item for "file1"
         # - a hardlink item for "CACHEDIR.TAG" referring back to file1 for its contents
-        self.cmd(f'--repo={self.repository_location}::test', 'recreate', '--exclude-caches', '--keep-exclude-tags')
+        self.cmd(f'--repo={self.repository_location}', 'recreate', '--name=test', '--exclude-caches', '--keep-exclude-tags')
         # if issue #4911 is present, the recreate will crash with a KeyError for "input/file1"
 
     @pytest.mark.skipif(not xattr.XATTR_FAKEROOT, reason='Linux capabilities test, requires fakeroot >= 1.20.2')
@@ -1409,10 +1410,10 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self.create_regular_file('file')
         xattr.setxattr(b'input/file', b'security.capability', capabilities)
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
-        self.cmd(f'--repo={self.repository_location}::test', 'create', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', 'input')
         with changedir('output'):
             with patch.object(os, 'fchown', patched_fchown):
-                self.cmd(f'--repo={self.repository_location}::test', 'extract')
+                self.cmd(f'--repo={self.repository_location}', 'extract', '--name=test')
             assert xattr.getxattr(b'input/file', b'security.capability') == capabilities
 
     @pytest.mark.skipif(not xattr.XATTR_FAKEROOT, reason='xattr not supported on this system or on this version of'
@@ -1430,19 +1431,19 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self.create_regular_file('file')
         xattr.setxattr(b'input/file', b'user.attribute', b'value')
         self.cmd(f'--repo={self.repository_location}', 'init', '-e' 'none')
-        self.cmd(f'--repo={self.repository_location}::test', 'create', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', 'input')
         with changedir('output'):
             input_abspath = os.path.abspath('input/file')
             with patch.object(xattr, 'setxattr', patched_setxattr_E2BIG):
-                out = self.cmd(f'--repo={self.repository_location}::test', 'extract', exit_code=EXIT_WARNING)
+                out = self.cmd(f'--repo={self.repository_location}', 'extract', '--name=test', exit_code=EXIT_WARNING)
                 assert ': when setting extended attribute user.attribute: too big for this filesystem\n' in out
             os.remove(input_abspath)
             with patch.object(xattr, 'setxattr', patched_setxattr_ENOTSUP):
-                out = self.cmd(f'--repo={self.repository_location}::test', 'extract', exit_code=EXIT_WARNING)
+                out = self.cmd(f'--repo={self.repository_location}', 'extract', '--name=test', exit_code=EXIT_WARNING)
                 assert ': when setting extended attribute user.attribute: xattrs not supported on this filesystem\n' in out
             os.remove(input_abspath)
             with patch.object(xattr, 'setxattr', patched_setxattr_EACCES):
-                out = self.cmd(f'--repo={self.repository_location}::test', 'extract', exit_code=EXIT_WARNING)
+                out = self.cmd(f'--repo={self.repository_location}', 'extract', '--name=test', exit_code=EXIT_WARNING)
                 assert ': when setting extended attribute user.attribute: Permission denied\n' in out
             assert os.path.isfile(input_abspath)
 
@@ -1450,8 +1451,9 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
         self.create_regular_file('dir1/dir2/file', size=1024 * 80)
         with changedir('input/dir1/dir2'):
-            self.cmd(f'--repo={self.repository_location}::test', 'create', '../../../input/dir1/../dir1/dir2/..')
-        output = self.cmd(f'--repo={self.repository_location}::test', 'list')
+            self.cmd(f'--repo={self.repository_location}', 'create', '--name=test',
+                     '../../../input/dir1/../dir1/dir2/..')
+        output = self.cmd(f'--repo={self.repository_location}', 'list', '--name=test')
         self.assert_not_in('..', output)
         self.assert_in(' input/dir1/dir2/file', output)
 
@@ -1460,57 +1462,57 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self.create_regular_file('file1', size=1024 * 80)
         self.create_regular_file('file2', size=1024 * 80)
         with changedir('input'):
-            self.cmd(f'--repo={self.repository_location}::test1', 'create', '--exclude=file1', '.')
+            self.cmd(f'--repo={self.repository_location}', 'create', '--name=test1', '--exclude=file1', '.')
         with changedir('output'):
-            self.cmd(f'--repo={self.repository_location}::test1', 'extract')
+            self.cmd(f'--repo={self.repository_location}', 'extract', '--name=test1')
         self.assert_equal(sorted(os.listdir('output')), ['file2'])
         with changedir('input'):
-            self.cmd(f'--repo={self.repository_location}::test2', 'create', '--exclude=./file1', '.')
+            self.cmd(f'--repo={self.repository_location}', 'create', '--name=test2', '--exclude=./file1', '.')
         with changedir('output'):
-            self.cmd(f'--repo={self.repository_location}::test2', 'extract')
+            self.cmd(f'--repo={self.repository_location}', 'extract', '--name=test2')
         self.assert_equal(sorted(os.listdir('output')), ['file2'])
-        self.cmd(f'--repo={self.repository_location}::test3', 'create', '--exclude=input/./file1', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test3', '--exclude=input/./file1', 'input')
         with changedir('output'):
-            self.cmd(f'--repo={self.repository_location}::test3', 'extract')
+            self.cmd(f'--repo={self.repository_location}', 'extract', '--name=test3')
         self.assert_equal(sorted(os.listdir('output/input')), ['file2'])
 
     def test_repeated_files(self):
         self.create_regular_file('file1', size=1024 * 80)
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
-        self.cmd(f'--repo={self.repository_location}::test', 'create', 'input', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', 'input', 'input')
 
     def test_overwrite(self):
         self.create_regular_file('file1', size=1024 * 80)
         self.create_regular_file('dir2/file2', size=1024 * 80)
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
-        self.cmd(f'--repo={self.repository_location}::test', 'create', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', 'input')
         # Overwriting regular files and directories should be supported
         os.mkdir('output/input')
         os.mkdir('output/input/file1')
         os.mkdir('output/input/dir2')
         with changedir('output'):
-            self.cmd(f'--repo={self.repository_location}::test', 'extract')
+            self.cmd(f'--repo={self.repository_location}', 'extract', '--name=test')
         self.assert_dirs_equal('input', 'output/input')
         # But non-empty dirs should fail
         os.unlink('output/input/file1')
         os.mkdir('output/input/file1')
         os.mkdir('output/input/file1/dir')
         with changedir('output'):
-            self.cmd(f'--repo={self.repository_location}::test', 'extract', exit_code=1)
+            self.cmd(f'--repo={self.repository_location}', 'extract', '--name=test', exit_code=1)
 
     def test_rename(self):
         self.create_regular_file('file1', size=1024 * 80)
         self.create_regular_file('dir2/file2', size=1024 * 80)
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
-        self.cmd(f'--repo={self.repository_location}::test', 'create', 'input')
-        self.cmd(f'--repo={self.repository_location}::test.2', 'create', 'input')
-        self.cmd(f'--repo={self.repository_location}::test', 'extract', '--dry-run')
-        self.cmd(f'--repo={self.repository_location}::test.2', 'extract', '--dry-run')
-        self.cmd(f'--repo={self.repository_location}::test', 'rename', 'TODO_test', 'test.3')
-        self.cmd(f'--repo={self.repository_location}::test.2', 'extract', '--dry-run')
-        self.cmd(f'--repo={self.repository_location}::test.2', 'rename', 'TODO_test.2', 'test.4')
-        self.cmd(f'--repo={self.repository_location}::test.3', 'extract', '--dry-run')
-        self.cmd(f'--repo={self.repository_location}::test.4', 'extract', '--dry-run')
+        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test.2', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'extract', '--name=test', '--dry-run')
+        self.cmd(f'--repo={self.repository_location}', 'extract', '--name=test.2', '--dry-run')
+        self.cmd(f'--repo={self.repository_location}', 'rename', '--name=test', '--name2=test.3')
+        self.cmd(f'--repo={self.repository_location}', 'extract', '--name=test.2', '--dry-run')
+        self.cmd(f'--repo={self.repository_location}', 'rename', '--name=test.2', '--name2=test.4')
+        self.cmd(f'--repo={self.repository_location}', 'extract', '--name=test.3', '--dry-run')
+        self.cmd(f'--repo={self.repository_location}', 'extract', '--name=test.4', '--dry-run')
         # Make sure both archives have been renamed
         with Repository(self.repository_path) as repository:
             manifest, key = Manifest.load(repository, Manifest.NO_OPERATION_CHECK)
@@ -1521,10 +1523,10 @@ class ArchiverTestCase(ArchiverTestCaseBase):
     def test_info(self):
         self.create_regular_file('file1', size=1024 * 80)
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
-        self.cmd(f'--repo={self.repository_location}::test', 'create', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', 'input')
         info_repo = self.cmd(f'--repo={self.repository_location}', 'info')
         assert 'All archives:' in info_repo
-        info_archive = self.cmd(f'--repo={self.repository_location}::test', 'info')
+        info_archive = self.cmd(f'--repo={self.repository_location}', 'info', '--name=test')
         assert 'Archive name: test\n' in info_archive
         info_archive = self.cmd(f'--repo={self.repository_location}', 'info', '--first', '1')
         assert 'Archive name: test\n' in info_archive
@@ -1532,7 +1534,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
     def test_info_json(self):
         self.create_regular_file('file1', size=1024 * 80)
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
-        self.cmd(f'--repo={self.repository_location}::test', 'create', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', 'input')
         info_repo = json.loads(self.cmd(f'--repo={self.repository_location}', 'info', '--json'))
         repository = info_repo['repository']
         assert len(repository['id']) == 64
@@ -1545,7 +1547,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         assert all(isinstance(o, int) for o in stats.values())
         assert all(key in stats for key in ('total_chunks', 'total_size', 'total_unique_chunks', 'unique_size'))
 
-        info_archive = json.loads(self.cmd(f'--repo={self.repository_location}::test', 'info', '--json'))
+        info_archive = json.loads(self.cmd(f'--repo={self.repository_location}', 'info', '--name=test', '--json'))
         assert info_repo['repository'] == info_archive['repository']
         assert info_repo['cache'] == info_archive['cache']
         archives = info_archive['archives']
@@ -1570,38 +1572,38 @@ class ArchiverTestCase(ArchiverTestCaseBase):
     def test_comment(self):
         self.create_regular_file('file1', size=1024 * 80)
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
-        self.cmd(f'--repo={self.repository_location}::test1', 'create', 'input')
-        self.cmd(f'--repo={self.repository_location}::test2', 'create', '--comment', 'this is the comment', 'input')
-        self.cmd(f'--repo={self.repository_location}::test3', 'create', '--comment', '"deleted" comment', 'input')
-        self.cmd(f'--repo={self.repository_location}::test4', 'create', '--comment', 'preserved comment', 'input')
-        assert 'Comment: \n' in self.cmd(f'--repo={self.repository_location}::test1', 'info')
-        assert 'Comment: this is the comment' in self.cmd(f'--repo={self.repository_location}::test2', 'info')
+        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test1', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test2', '--comment', 'this is the comment', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test3', '--comment', '"deleted" comment', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test4', '--comment', 'preserved comment', 'input')
+        assert 'Comment: \n' in self.cmd(f'--repo={self.repository_location}', 'info', '--name=test1')
+        assert 'Comment: this is the comment' in self.cmd(f'--repo={self.repository_location}', 'info', '--name=test2')
 
-        self.cmd(f'--repo={self.repository_location}::test1', 'recreate', '--comment', 'added comment')
-        self.cmd(f'--repo={self.repository_location}::test2', 'recreate', '--comment', 'modified comment')
-        self.cmd(f'--repo={self.repository_location}::test3', 'recreate', '--comment', '')
-        self.cmd(f'--repo={self.repository_location}::test4', 'recreate', '12345')
-        assert 'Comment: added comment' in self.cmd(f'--repo={self.repository_location}::test1', 'info')
-        assert 'Comment: modified comment' in self.cmd(f'--repo={self.repository_location}::test2', 'info')
-        assert 'Comment: \n' in self.cmd(f'--repo={self.repository_location}::test3', 'info')
-        assert 'Comment: preserved comment' in self.cmd(f'--repo={self.repository_location}::test4', 'info')
+        self.cmd(f'--repo={self.repository_location}', 'recreate', '--name=test1', '--comment', 'added comment')
+        self.cmd(f'--repo={self.repository_location}', 'recreate', '--name=test2', '--comment', 'modified comment')
+        self.cmd(f'--repo={self.repository_location}', 'recreate', '--name=test3', '--comment', '')
+        self.cmd(f'--repo={self.repository_location}', 'recreate', '--name=test4', '12345')
+        assert 'Comment: added comment' in self.cmd(f'--repo={self.repository_location}', 'info', '--name=test1')
+        assert 'Comment: modified comment' in self.cmd(f'--repo={self.repository_location}', 'info', '--name=test2')
+        assert 'Comment: \n' in self.cmd(f'--repo={self.repository_location}', 'info', '--name=test3')
+        assert 'Comment: preserved comment' in self.cmd(f'--repo={self.repository_location}', 'info', '--name=test4')
 
     def test_delete(self):
         self.create_regular_file('file1', size=1024 * 80)
         self.create_regular_file('dir2/file2', size=1024 * 80)
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
-        self.cmd(f'--repo={self.repository_location}::test', 'create', 'input')
-        self.cmd(f'--repo={self.repository_location}::test.2', 'create', 'input')
-        self.cmd(f'--repo={self.repository_location}::test.3', 'create', 'input')
-        self.cmd(f'--repo={self.repository_location}::another_test.1', 'create', 'input')
-        self.cmd(f'--repo={self.repository_location}::another_test.2', 'create', 'input')
-        self.cmd(f'--repo={self.repository_location}::test', 'extract', '--dry-run')
-        self.cmd(f'--repo={self.repository_location}::test.2', 'extract', '--dry-run')
+        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test.2', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test.3', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'create', '--name=another_test.1', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'create', '--name=another_test.2', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'extract', '--name=test', '--dry-run')
+        self.cmd(f'--repo={self.repository_location}', 'extract', '--name=test.2', '--dry-run')
         self.cmd(f'--repo={self.repository_location}', 'delete', '--prefix', 'another_')
         self.cmd(f'--repo={self.repository_location}', 'delete', '--last', '1')
-        self.cmd(f'--repo={self.repository_location}::test', 'delete')
-        self.cmd(f'--repo={self.repository_location}::test.2', 'extract', '--dry-run')
-        output = self.cmd(f'--repo={self.repository_location}::test.2', 'delete', '--stats')
+        self.cmd(f'--repo={self.repository_location}', 'delete', '--name=test')
+        self.cmd(f'--repo={self.repository_location}', 'extract', '--name=test.2', '--dry-run')
+        output = self.cmd(f'--repo={self.repository_location}', 'delete', '--name=test.2', '--stats')
         self.assert_in('Deleted data:', output)
         # Make sure all data except the manifest has been deleted
         with Repository(self.repository_path) as repository:
@@ -1610,20 +1612,20 @@ class ArchiverTestCase(ArchiverTestCaseBase):
     def test_delete_multiple(self):
         self.create_regular_file('file1', size=1024 * 80)
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
-        self.cmd(f'--repo={self.repository_location}::test1', 'create', 'input')
-        self.cmd(f'--repo={self.repository_location}::test2', 'create', 'input')
-        self.cmd(f'--repo={self.repository_location}::test3', 'create', 'input')
-        self.cmd(f'--repo={self.repository_location}::test1', 'delete', 'test2')
-        self.cmd(f'--repo={self.repository_location}::test3', 'extract', '--dry-run')
-        self.cmd(f'--repo={self.repository_location}::test3', 'delete')
+        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test1', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test2', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test3', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'delete', '--name=test1', 'test2')
+        self.cmd(f'--repo={self.repository_location}', 'extract', '--name=test3', '--dry-run')
+        self.cmd(f'--repo={self.repository_location}', 'delete', '--name=test3')
         assert not self.cmd(f'--repo={self.repository_location}', 'list')
 
     def test_delete_repo(self):
         self.create_regular_file('file1', size=1024 * 80)
         self.create_regular_file('dir2/file2', size=1024 * 80)
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
-        self.cmd(f'--repo={self.repository_location}::test', 'create', 'input')
-        self.cmd(f'--repo={self.repository_location}::test.2', 'create', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test.2', 'input')
         os.environ['BORG_DELETE_I_KNOW_WHAT_I_AM_DOING'] = 'no'
         self.cmd(f'--repo={self.repository_location}', 'delete', exit_code=2)
         assert os.path.exists(self.repository_path)
@@ -1645,7 +1647,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
             else:
                 assert False  # missed the file
             repository.commit(compact=False)
-        output = self.cmd(f'--repo={self.repository_location}::test', 'delete', '--force')
+        output = self.cmd(f'--repo={self.repository_location}', 'delete', '--name=test', '--force')
         self.assert_in('deleted archive was corrupted', output)
         self.cmd(f'--repo={self.repository_location}', 'check', '--repair')
         output = self.cmd(f'--repo={self.repository_location}', 'list')
@@ -1660,7 +1662,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
             id = archive.metadata.items[0]
             repository.put(id, b'corrupted items metadata stream chunk')
             repository.commit(compact=False)
-        self.cmd(f'--repo={self.repository_location}::test', 'delete', '--force', '--force')
+        self.cmd(f'--repo={self.repository_location}', 'delete', '--name=test', '--force', '--force')
         self.cmd(f'--repo={self.repository_location}', 'check', '--repair')
         output = self.cmd(f'--repo={self.repository_location}', 'list')
         self.assert_not_in('test', output)
@@ -1668,7 +1670,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
     def test_corrupted_repository(self):
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
         self.create_src_archive('test')
-        self.cmd(f'--repo={self.repository_location}::test', 'extract', '--dry-run')
+        self.cmd(f'--repo={self.repository_location}', 'extract', '--name=test', '--dry-run')
         output = self.cmd(f'--repo={self.repository_location}', 'check', '--show-version')
         self.assert_in('borgbackup version', output)  # implied output even without --info given
         self.assert_not_in('Starting repository check', output)  # --info not given for root logger
@@ -1702,14 +1704,14 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         with self.read_only(self.repository_path):
             # verify that command normally doesn't work with read-only repo
             if self.FORK_DEFAULT:
-                self.cmd(f'--repo={self.repository_location}::a', 'diff', 'TODO_a', 'b', exit_code=EXIT_ERROR)
+                self.cmd(f'--repo={self.repository_location}', 'diff', '--name=a', '--name2=b', exit_code=EXIT_ERROR)
             else:
                 with pytest.raises((LockFailed, RemoteRepository.RPCError)) as excinfo:
-                    self.cmd(f'--repo={self.repository_location}::a', 'diff', 'TODO_a', 'b')
+                    self.cmd(f'--repo={self.repository_location}', 'diff', '--name=a', '--name=b')
                 if isinstance(excinfo.value, RemoteRepository.RPCError):
                     assert excinfo.value.exception_class == 'LockFailed'
             # verify that command works with read-only repo when using --bypass-lock
-            self.cmd(f'--repo={self.repository_location}::a', 'diff', 'TODO_a', 'b', '--bypass-lock')
+            self.cmd(f'--repo={self.repository_location}', 'diff', '--name=a', '--name2=b', '--bypass-lock')
 
     def test_readonly_export_tar(self):
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
@@ -1717,14 +1719,14 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         with self.read_only(self.repository_path):
             # verify that command normally doesn't work with read-only repo
             if self.FORK_DEFAULT:
-                self.cmd(f'--repo={self.repository_location}::test', 'export-tar', 'test.tar', exit_code=EXIT_ERROR)
+                self.cmd(f'--repo={self.repository_location}', 'export-tar', '--name=test', 'test.tar', exit_code=EXIT_ERROR)
             else:
                 with pytest.raises((LockFailed, RemoteRepository.RPCError)) as excinfo:
-                    self.cmd(f'--repo={self.repository_location}::test', 'export-tar', 'test.tar')
+                    self.cmd(f'--repo={self.repository_location}', 'export-tar', '--name=test', 'test.tar')
                 if isinstance(excinfo.value, RemoteRepository.RPCError):
                     assert excinfo.value.exception_class == 'LockFailed'
             # verify that command works with read-only repo when using --bypass-lock
-            self.cmd(f'--repo={self.repository_location}::test', 'export-tar', 'test.tar', '--bypass-lock')
+            self.cmd(f'--repo={self.repository_location}', 'export-tar', '--name=test', 'test.tar', '--bypass-lock')
 
     def test_readonly_extract(self):
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
@@ -1732,14 +1734,14 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         with self.read_only(self.repository_path):
             # verify that command normally doesn't work with read-only repo
             if self.FORK_DEFAULT:
-                self.cmd(f'--repo={self.repository_location}::test', 'extract', exit_code=EXIT_ERROR)
+                self.cmd(f'--repo={self.repository_location}', 'extract', '--name=test', exit_code=EXIT_ERROR)
             else:
                 with pytest.raises((LockFailed, RemoteRepository.RPCError)) as excinfo:
-                    self.cmd(f'--repo={self.repository_location}::test', 'extract')
+                    self.cmd(f'--repo={self.repository_location}', 'extract', '--name=test')
                 if isinstance(excinfo.value, RemoteRepository.RPCError):
                     assert excinfo.value.exception_class == 'LockFailed'
             # verify that command works with read-only repo when using --bypass-lock
-            self.cmd(f'--repo={self.repository_location}::test', 'extract', '--bypass-lock')
+            self.cmd(f'--repo={self.repository_location}', 'extract', '--name=test', '--bypass-lock')
 
     def test_readonly_info(self):
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
@@ -1795,13 +1797,13 @@ class ArchiverTestCase(ArchiverTestCaseBase):
     def test_umask(self):
         self.create_regular_file('file1', size=1024 * 80)
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
-        self.cmd(f'--repo={self.repository_location}::test', 'create', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', 'input')
         mode = os.stat(self.repository_path).st_mode
         self.assertEqual(stat.S_IMODE(mode), 0o700)
 
     def test_create_dry_run(self):
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
-        self.cmd(f'--repo={self.repository_location}::test', 'create', '--dry-run', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', '--dry-run', 'input')
         # Make sure no archive has been created
         with Repository(self.repository_path) as repository:
             manifest, key = Manifest.load(repository, Manifest.NO_OPERATION_CHECK)
@@ -1825,13 +1827,13 @@ class ArchiverTestCase(ArchiverTestCaseBase):
     def test_unknown_feature_on_create(self):
         print(self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey'))
         self.add_unknown_feature(Manifest.Operation.WRITE)
-        self.cmd_raises_unknown_feature([f'--repo={self.repository_location}::test', 'create', 'input'])
+        self.cmd_raises_unknown_feature([f'--repo={self.repository_location}', 'create', '--name=test', 'input'])
 
     def test_unknown_feature_on_cache_sync(self):
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
         self.cmd(f'--repo={self.repository_location}', 'delete', '--cache-only')
         self.add_unknown_feature(Manifest.Operation.READ)
-        self.cmd_raises_unknown_feature([f'--repo={self.repository_location}::test', 'create', 'input'])
+        self.cmd_raises_unknown_feature([f'--repo={self.repository_location}', 'create', '--name=test', 'input'])
 
     def test_unknown_feature_on_change_passphrase(self):
         print(self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey'))
@@ -1840,26 +1842,26 @@ class ArchiverTestCase(ArchiverTestCaseBase):
 
     def test_unknown_feature_on_read(self):
         print(self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey'))
-        self.cmd(f'--repo={self.repository_location}::test', 'create', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', 'input')
         self.add_unknown_feature(Manifest.Operation.READ)
         with changedir('output'):
-            self.cmd_raises_unknown_feature([f'--repo={self.repository_location}::test', 'extract'])
+            self.cmd_raises_unknown_feature([f'--repo={self.repository_location}', 'extract', '--name=test'])
 
         self.cmd_raises_unknown_feature([f'--repo={self.repository_location}', 'list'])
-        self.cmd_raises_unknown_feature([f'--repo={self.repository_location}::test', 'info'])
+        self.cmd_raises_unknown_feature([f'--repo={self.repository_location}', 'info', '--name=test'])
 
     def test_unknown_feature_on_rename(self):
         print(self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey'))
-        self.cmd(f'--repo={self.repository_location}::test', 'create', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', 'input')
         self.add_unknown_feature(Manifest.Operation.CHECK)
-        self.cmd_raises_unknown_feature([f'--repo={self.repository_location}::test', 'rename', 'TODO_test', 'other'])
+        self.cmd_raises_unknown_feature([f'--repo={self.repository_location}', 'rename', '--name=test', '--name2=other'])
 
     def test_unknown_feature_on_delete(self):
         print(self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey'))
-        self.cmd(f'--repo={self.repository_location}::test', 'create', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', 'input')
         self.add_unknown_feature(Manifest.Operation.DELETE)
         # delete of an archive raises
-        self.cmd_raises_unknown_feature([f'--repo={self.repository_location}::test', 'delete'])
+        self.cmd_raises_unknown_feature([f'--repo={self.repository_location}', 'delete', '--name=test'])
         self.cmd_raises_unknown_feature([f'--repo={self.repository_location}', 'prune', '--keep-daily=3'])
         # delete of the whole repository ignores features
         self.cmd(f'--repo={self.repository_location}', 'delete')
@@ -1867,7 +1869,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
     @unittest.skipUnless(llfuse, 'llfuse not installed')
     def test_unknown_feature_on_mount(self):
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
-        self.cmd(f'--repo={self.repository_location}::test', 'create', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', 'input')
         self.add_unknown_feature(Manifest.Operation.READ)
         mountpoint = os.path.join(self.tmpdir, 'mountpoint')
         os.mkdir(mountpoint)
@@ -1893,7 +1895,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
                 cache.commit()
 
         if self.FORK_DEFAULT:
-            self.cmd(f'--repo={self.repository_location}::test', 'create', 'input')
+            self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', 'input')
         else:
             called = False
             wipe_cache_safe = LocalCache.wipe_cache
@@ -1904,7 +1906,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
                 wipe_cache_safe(*args)
 
             with patch.object(LocalCache, 'wipe_cache', wipe_wrapper):
-                self.cmd(f'--repo={self.repository_location}::test', 'create', 'input')
+                self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', 'input')
 
             assert called
 
@@ -1918,13 +1920,13 @@ class ArchiverTestCase(ArchiverTestCaseBase):
     def test_progress_on(self):
         self.create_regular_file('file1', size=1024 * 80)
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
-        output = self.cmd(f'--repo={self.repository_location}::test4', 'create', '--progress', 'input')
+        output = self.cmd(f'--repo={self.repository_location}', 'create', '--name=test4', '--progress', 'input')
         self.assert_in("\r", output)
 
     def test_progress_off(self):
         self.create_regular_file('file1', size=1024 * 80)
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
-        output = self.cmd(f'--repo={self.repository_location}::test5', 'create', 'input')
+        output = self.cmd(f'--repo={self.repository_location}', 'create', '--name=test5', 'input')
         self.assert_not_in("\r", output)
 
     def test_file_status(self):
@@ -1935,11 +1937,11 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         time.sleep(1)  # file2 must have newer timestamps than file1
         self.create_regular_file('file2', size=1024 * 80)
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
-        output = self.cmd(f'--repo={self.repository_location}::test', 'create', '--list', 'input')
+        output = self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', '--list', 'input')
         self.assert_in("A input/file1", output)
         self.assert_in("A input/file2", output)
         # should find first file as unmodified
-        output = self.cmd(f'--repo={self.repository_location}::test1', 'create', '--list', 'input')
+        output = self.cmd(f'--repo={self.repository_location}', 'create', '--name=test2', '--list', 'input')
         self.assert_in("U input/file1", output)
         # this is expected, although surprising, for why, see:
         # https://borgbackup.readthedocs.org/en/latest/faq.html#i-am-seeing-a-added-status-for-a-unchanged-file
@@ -1951,14 +1953,14 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         time.sleep(1)  # file2 must have newer timestamps than file1
         self.create_regular_file('file2', size=10)
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
-        output = self.cmd(f'--repo={self.repository_location}::test1', 'create',
+        output = self.cmd(f'--repo={self.repository_location}', 'create', '--name=test1',
                           '--list', '--files-cache=ctime,size', 'input')
         # modify file1, but cheat with the mtime (and atime) and also keep same size:
         st = os.stat('input/file1')
         self.create_regular_file('file1', contents=b'321')
         os.utime('input/file1', ns=(st.st_atime_ns, st.st_mtime_ns))
         # this mode uses ctime for change detection, so it should find file1 as modified
-        output = self.cmd(f'--repo={self.repository_location}::test2', 'create',
+        output = self.cmd(f'--repo={self.repository_location}', 'create', '--name=test2',
                           '--list', '--files-cache=ctime,size', 'input')
         self.assert_in("M input/file1", output)
 
@@ -1968,13 +1970,13 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         time.sleep(1)  # file2 must have newer timestamps than file1
         self.create_regular_file('file2', size=10)
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
-        output = self.cmd(f'--repo={self.repository_location}::test1', 'create',
+        output = self.cmd(f'--repo={self.repository_location}', 'create', '--name=test1',
                           '--list', '--files-cache=mtime,size', 'input')
         # change mode of file1, no content change:
         st = os.stat('input/file1')
         os.chmod('input/file1', st.st_mode ^ stat.S_IRWXO)  # this triggers a ctime change, but mtime is unchanged
         # this mode uses mtime for change detection, so it should find file1 as unmodified
-        output = self.cmd(f'--repo={self.repository_location}::test2', 'create',
+        output = self.cmd(f'--repo={self.repository_location}', 'create', '--name=test2',
                           '--list', '--files-cache=mtime,size', 'input')
         self.assert_in("U input/file1", output)
 
@@ -1984,10 +1986,10 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         time.sleep(1)  # file2 must have newer timestamps than file1
         self.create_regular_file('file2', size=10)
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
-        output = self.cmd(f'--repo={self.repository_location}::test1', 'create',
+        output = self.cmd(f'--repo={self.repository_location}', 'create', '--name=test1',
                           '--list', '--files-cache=rechunk,ctime', 'input')
         # no changes here, but this mode rechunks unconditionally
-        output = self.cmd(f'--repo={self.repository_location}::test2', 'create',
+        output = self.cmd(f'--repo={self.repository_location}', 'create', '--name=test2',
                           '--list', '--files-cache=rechunk,ctime', 'input')
         self.assert_in("A input/file1", output)
 
@@ -2001,13 +2003,13 @@ class ArchiverTestCase(ArchiverTestCaseBase):
             self.create_regular_file('file3', size=1024 * 80)
             platform.set_flags(os.path.join(self.input_path, 'file3'), stat.UF_NODUMP)
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
-        output = self.cmd(f'--repo={self.repository_location}::test', 'create', '--list', '--exclude-nodump', 'input')
+        output = self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', '--list', '--exclude-nodump', 'input')
         self.assert_in("A input/file1", output)
         self.assert_in("A input/file2", output)
         if has_lchflags:
             self.assert_in("x input/file3", output)
         # should find second file as excluded
-        output = self.cmd(f'--repo={self.repository_location}::test1', 'create',
+        output = self.cmd(f'--repo={self.repository_location}', 'create', '--name=test1',
                           '--list', '--exclude-nodump', 'input', '--exclude', '*/file2')
         self.assert_in("U input/file1", output)
         self.assert_in("x input/file2", output)
@@ -2017,7 +2019,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
     def test_create_json(self):
         self.create_regular_file('file1', size=1024 * 80)
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
-        create_info = json.loads(self.cmd(f'--repo={self.repository_location}::test', 'create',
+        create_info = json.loads(self.cmd(f'--repo={self.repository_location}', 'create', '--name=test',
                                           '--json', 'input'))
         # The usual keys
         assert 'encryption' in create_info
@@ -2038,21 +2040,21 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self.create_regular_file('file2', size=1024 * 80)
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
         # no listing by default
-        output = self.cmd(f'--repo={self.repository_location}::test', 'create', 'input')
+        output = self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', 'input')
         self.assert_not_in('file1', output)
         # shouldn't be listed even if unchanged
-        output = self.cmd(f'--repo={self.repository_location}::test0', 'create', 'input')
+        output = self.cmd(f'--repo={self.repository_location}', 'create', '--name=test0', 'input')
         self.assert_not_in('file1', output)
         # should list the file as unchanged
-        output = self.cmd(f'--repo={self.repository_location}::test1', 'create', '--list', '--filter=U', 'input')
+        output = self.cmd(f'--repo={self.repository_location}', 'create', '--name=test1', '--list', '--filter=U', 'input')
         self.assert_in('file1', output)
         # should *not* list the file as changed
-        output = self.cmd(f'--repo={self.repository_location}::test2', 'create', '--list', '--filter=AM', 'input')
+        output = self.cmd(f'--repo={self.repository_location}', 'create', '--name=test2', '--list', '--filter=AM', 'input')
         self.assert_not_in('file1', output)
         # change the file
         self.create_regular_file('file1', size=1024 * 100)
         # should list the file as changed
-        output = self.cmd(f'--repo={self.repository_location}::test3', 'create', '--list', '--filter=AM', 'input')
+        output = self.cmd(f'--repo={self.repository_location}', 'create', '--name=test3', '--list', '--filter=AM', 'input')
         self.assert_in('file1', output)
 
     @pytest.mark.skipif(not are_fifos_supported(), reason='FIFOs not supported')
@@ -2077,11 +2079,11 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         t = Thread(target=fifo_feeder, args=(fifo_fn, data))
         t.start()
         try:
-            self.cmd(f'--repo={self.repository_location}::test', 'create', '--read-special', 'input/link_fifo')
+            self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', '--read-special', 'input/link_fifo')
         finally:
             t.join()
         with changedir('output'):
-            self.cmd(f'--repo={self.repository_location}::test', 'extract')
+            self.cmd(f'--repo={self.repository_location}', 'extract', '--name=test')
             fifo_fn = 'input/link_fifo'
             with open(fifo_fn, 'rb') as f:
                 extracted_data = f.read()
@@ -2090,25 +2092,25 @@ class ArchiverTestCase(ArchiverTestCaseBase):
     def test_create_read_special_broken_symlink(self):
         os.symlink('somewhere does not exist', os.path.join(self.input_path, 'link'))
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
-        self.cmd(f'--repo={self.repository_location}::test', 'create', '--read-special', 'input')
-        output = self.cmd(f'--repo={self.repository_location}::test', 'list')
+        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', '--read-special', 'input')
+        output = self.cmd(f'--repo={self.repository_location}', 'list', '--name=test')
         assert 'input/link -> somewhere does not exist' in output
 
     # def test_cmdline_compatibility(self):
     #    self.create_regular_file('file1', size=1024 * 80)
     #    self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
-    #    self.cmd('create', self.repository_location + '::test', 'input')
+    #    self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', 'input')
     #    output = self.cmd('foo', self.repository_location, '--old')
     #    self.assert_in('"--old" has been deprecated. Use "--new" instead', output)
 
     def test_prune_repository(self):
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
-        self.cmd(f'--repo={self.repository_location}::test1', 'create', src_dir)
-        self.cmd(f'--repo={self.repository_location}::test2', 'create', src_dir)
+        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test1', src_dir)
+        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test2', src_dir)
         # these are not really a checkpoints, but they look like some:
-        self.cmd(f'--repo={self.repository_location}::test3.checkpoint', 'create', src_dir)
-        self.cmd(f'--repo={self.repository_location}::test3.checkpoint.1', 'create', src_dir)
-        self.cmd(f'--repo={self.repository_location}::test4.checkpoint', 'create', src_dir)
+        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test3.checkpoint', src_dir)
+        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test3.checkpoint.1', src_dir)
+        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test4.checkpoint', src_dir)
         output = self.cmd(f'--repo={self.repository_location}', 'prune', '--list', '--dry-run', '--keep-daily=1')
         assert re.search(r'Would prune:\s+test1', output)
         # must keep the latest non-checkpoint archive:
@@ -2131,7 +2133,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self.assert_not_in('test3.checkpoint.1', output)
         self.assert_in('test4.checkpoint', output)
         # now we supersede the latest checkpoint by a successful backup:
-        self.cmd(f'--repo={self.repository_location}::test5', 'create', src_dir)
+        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test5', src_dir)
         self.cmd(f'--repo={self.repository_location}', 'prune', '--keep-daily=2')
         output = self.cmd(f'--repo={self.repository_location}', 'list', '--consider-checkpoints')
         # all checkpoints should be gone now:
@@ -2146,7 +2148,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         return dtime.astimezone(dateutil.tz.UTC).strftime("%Y-%m-%dT%H:%M:%S")
 
     def _create_archive_ts(self, name, y, m, d, H=0, M=0, S=0):
-        self.cmd(f'--repo={self.repository_location}::{name}', 'create',
+        self.cmd(f'--repo={self.repository_location}', 'create', f'--name={name}',
                  '--timestamp', self._to_utc_timestamp(y, m, d, H, M, S), src_dir)
 
     # This test must match docs/misc/prune-example.txt
@@ -2236,8 +2238,8 @@ class ArchiverTestCase(ArchiverTestCaseBase):
 
     def test_prune_repository_save_space(self):
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
-        self.cmd(f'--repo={self.repository_location}::test1', 'create', src_dir)
-        self.cmd(f'--repo={self.repository_location}::test2', 'create', src_dir)
+        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test1', src_dir)
+        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test2', src_dir)
         output = self.cmd(f'--repo={self.repository_location}', 'prune', '--list', '--dry-run', '--keep-daily=1')
         assert re.search(r'Keeping archive \(rule: daily #1\):\s+test2', output)
         assert re.search(r'Would prune:\s+test1', output)
@@ -2251,10 +2253,10 @@ class ArchiverTestCase(ArchiverTestCaseBase):
 
     def test_prune_repository_prefix(self):
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
-        self.cmd(f'--repo={self.repository_location}::foo-2015-08-12-10:00', 'create', src_dir)
-        self.cmd(f'--repo={self.repository_location}::foo-2015-08-12-20:00', 'create', src_dir)
-        self.cmd(f'--repo={self.repository_location}::bar-2015-08-12-10:00', 'create', src_dir)
-        self.cmd(f'--repo={self.repository_location}::bar-2015-08-12-20:00', 'create', src_dir)
+        self.cmd(f'--repo={self.repository_location}', 'create', '--name=foo-2015-08-12-10:00', src_dir)
+        self.cmd(f'--repo={self.repository_location}', 'create', '--name=foo-2015-08-12-20:00', src_dir)
+        self.cmd(f'--repo={self.repository_location}', 'create', '--name=bar-2015-08-12-10:00', src_dir)
+        self.cmd(f'--repo={self.repository_location}', 'create', '--name=bar-2015-08-12-20:00', src_dir)
         output = self.cmd(f'--repo={self.repository_location}', 'prune', '--list', '--dry-run', '--keep-daily=1', '--prefix=foo-')
         assert re.search(r'Keeping archive \(rule: daily #1\):\s+foo-2015-08-12-20:00', output)
         assert re.search(r'Would prune:\s+foo-2015-08-12-10:00', output)
@@ -2272,10 +2274,10 @@ class ArchiverTestCase(ArchiverTestCaseBase):
 
     def test_prune_repository_glob(self):
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
-        self.cmd(f'--repo={self.repository_location}::2015-08-12-10:00-foo', 'create', src_dir)
-        self.cmd(f'--repo={self.repository_location}::2015-08-12-20:00-foo', 'create', src_dir)
-        self.cmd(f'--repo={self.repository_location}::2015-08-12-10:00-bar', 'create', src_dir)
-        self.cmd(f'--repo={self.repository_location}::2015-08-12-20:00-bar', 'create', src_dir)
+        self.cmd(f'--repo={self.repository_location}', 'create', '--name=2015-08-12-10:00-foo', src_dir)
+        self.cmd(f'--repo={self.repository_location}', 'create', '--name=2015-08-12-20:00-foo', src_dir)
+        self.cmd(f'--repo={self.repository_location}', 'create', '--name=2015-08-12-10:00-bar', src_dir)
+        self.cmd(f'--repo={self.repository_location}', 'create', '--name=2015-08-12-20:00-bar', src_dir)
         output = self.cmd(f'--repo={self.repository_location}', 'prune', '--list', '--dry-run', '--keep-daily=1', '--glob-archives=2015-*-foo')
         assert re.search(r'Keeping archive \(rule: daily #1\):\s+2015-08-12-20:00-foo', output)
         assert re.search(r'Would prune:\s+2015-08-12-10:00-foo', output)
@@ -2293,9 +2295,9 @@ class ArchiverTestCase(ArchiverTestCaseBase):
 
     def test_list_prefix(self):
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
-        self.cmd(f'--repo={self.repository_location}::test-1', 'create', src_dir)
-        self.cmd(f'--repo={self.repository_location}::something-else-than-test-1', 'create', src_dir)
-        self.cmd(f'--repo={self.repository_location}::test-2', 'create', src_dir)
+        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test-1', src_dir)
+        self.cmd(f'--repo={self.repository_location}', 'create', '--name=something-else-than-test-1', src_dir)
+        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test-2', src_dir)
         output = self.cmd(f'--repo={self.repository_location}', 'list', '--prefix=test-')
         self.assert_in('test-1', output)
         self.assert_in('test-2', output)
@@ -2303,17 +2305,17 @@ class ArchiverTestCase(ArchiverTestCaseBase):
 
     def test_list_format(self):
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
-        self.cmd(f'--repo={self.repository_location}::test', 'create', src_dir)
-        output_1 = self.cmd(f'--repo={self.repository_location}::test', 'list')
-        output_2 = self.cmd(f'--repo={self.repository_location}::test', 'list', '--format', '{mode} {user:6} {group:6} {size:8d} {mtime} {path}{extra}{NEWLINE}')
-        output_3 = self.cmd(f'--repo={self.repository_location}::test', 'list', '--format', '{mtime:%s} {path}{NL}')
+        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', src_dir)
+        output_1 = self.cmd(f'--repo={self.repository_location}', 'list', '--name=test')
+        output_2 = self.cmd(f'--repo={self.repository_location}', 'list', '--name=test', '--format', '{mode} {user:6} {group:6} {size:8d} {mtime} {path}{extra}{NEWLINE}')
+        output_3 = self.cmd(f'--repo={self.repository_location}', 'list', '--name=test', '--format', '{mtime:%s} {path}{NL}')
         self.assertEqual(output_1, output_2)
         self.assertNotEqual(output_1, output_3)
 
     def test_list_repository_format(self):
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
-        self.cmd(f'--repo={self.repository_location}::test-1', 'create', '--comment', 'comment 1', src_dir)
-        self.cmd(f'--repo={self.repository_location}::test-2', 'create', '--comment', 'comment 2', src_dir)
+        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test-1', '--comment', 'comment 1', src_dir)
+        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test-2', '--comment', 'comment 2', src_dir)
         output_1 = self.cmd(f'--repo={self.repository_location}', 'list')
         output_2 = self.cmd(f'--repo={self.repository_location}', 'list', '--format', '{archive:<36} {time} [{id}]{NL}')
         self.assertEqual(output_1, output_2)
@@ -2329,17 +2331,17 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self.create_regular_file('empty_file', size=0)
         self.create_regular_file('amb', contents=b'a' * 1000000)
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
-        self.cmd(f'--repo={self.repository_location}::test', 'create', 'input')
-        output = self.cmd(f'--repo={self.repository_location}::test', 'list', '--format', '{sha256} {path}{NL}')
+        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', 'input')
+        output = self.cmd(f'--repo={self.repository_location}', 'list', '--name=test', '--format', '{sha256} {path}{NL}')
         assert "cdc76e5c9914fb9281a1c7e284d73e67f1809a48a497200e046d39ccc7112cd0 input/amb" in output
         assert "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855 input/empty_file" in output
 
     def test_list_consider_checkpoints(self):
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
-        self.cmd(f'--repo={self.repository_location}::test1', 'create', src_dir)
+        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test1', src_dir)
         # these are not really a checkpoints, but they look like some:
-        self.cmd(f'--repo={self.repository_location}::test2.checkpoint', 'create', src_dir)
-        self.cmd(f'--repo={self.repository_location}::test3.checkpoint.1', 'create', src_dir)
+        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test2.checkpoint', src_dir)
+        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test3.checkpoint.1', src_dir)
         output = self.cmd(f'--repo={self.repository_location}', 'list')
         assert "test1" in output
         assert "test2.checkpoint" not in output
@@ -2356,23 +2358,23 @@ class ArchiverTestCase(ArchiverTestCaseBase):
             fd.write(b'abba' * 2000000)
             fd.write(b'baab' * 2000000)
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
-        self.cmd(f'--repo={self.repository_location}::test', 'create', 'input')
-        output = self.cmd(f'--repo={self.repository_location}::test', 'list', '--format', '{num_chunks} {unique_chunks} {path}{NL}')
+        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', 'input')
+        output = self.cmd(f'--repo={self.repository_location}', 'list', '--name=test', '--format', '{num_chunks} {unique_chunks} {path}{NL}')
         assert "0 0 input/empty_file" in output
         assert "2 2 input/two_chunks" in output
 
     def test_list_size(self):
         self.create_regular_file('compressible_file', size=10000)
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
-        self.cmd(f'--repo={self.repository_location}::test', 'create', '-C', 'lz4', 'input')
-        output = self.cmd(f'--repo={self.repository_location}::test', 'list', '--format', '{size} {path}{NL}')
+        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', '-C', 'lz4', 'input')
+        output = self.cmd(f'--repo={self.repository_location}', 'list', '--name=test', '--format', '{size} {path}{NL}')
         size, path = output.split("\n")[1].split(" ")
         assert int(size) == 10000
 
     def test_list_json(self):
         self.create_regular_file('file1', size=1024 * 80)
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
-        self.cmd(f'--repo={self.repository_location}::test', 'create', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', 'input')
         list_repo = json.loads(self.cmd(f'--repo={self.repository_location}', 'list', '--json'))
         repository = list_repo['repository']
         assert len(repository['id']) == 64
@@ -2382,7 +2384,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         archive0 = list_repo['archives'][0]
         assert datetime.strptime(archive0['time'], ISO_FORMAT)  # must not raise
 
-        list_archive = self.cmd(f'--repo={self.repository_location}::test', 'list', '--json-lines')
+        list_archive = self.cmd(f'--repo={self.repository_location}', 'list', '--name=test', '--json-lines')
         items = [json.loads(s) for s in list_archive.splitlines()]
         assert len(items) == 2
         file1 = items[1]
@@ -2390,7 +2392,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         assert file1['size'] == 81920
         assert datetime.strptime(file1['mtime'], ISO_FORMAT)  # must not raise
 
-        list_archive = self.cmd(f'--repo={self.repository_location}::test', 'list', '--json-lines', '--format={sha256}')
+        list_archive = self.cmd(f'--repo={self.repository_location}', 'list', '--name=test', '--json-lines', '--format={sha256}')
         items = [json.loads(s) for s in list_archive.splitlines()]
         assert len(items) == 2
         file1 = items[1]
@@ -2400,12 +2402,12 @@ class ArchiverTestCase(ArchiverTestCaseBase):
     def test_list_json_args(self):
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
         self.cmd(f'--repo={self.repository_location}', 'list', '--json-lines', exit_code=2)
-        self.cmd(f'--repo={self.repository_location}::archive', 'list', '--json', exit_code=2)
+        self.cmd(f'--repo={self.repository_location}', 'list', '--name=archive', '--json', exit_code=2)
 
     def test_log_json(self):
         self.create_test_files()
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
-        log = self.cmd(f'--repo={self.repository_location}::test', 'create', '--log-json', 'input', '--list', '--debug')
+        log = self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', '--log-json', 'input', '--list', '--debug')
         messages = {}  # type -> message, one of each kind
         for line in log.splitlines():
             msg = json.loads(line)
@@ -2423,13 +2425,13 @@ class ArchiverTestCase(ArchiverTestCaseBase):
     def test_debug_profile(self):
         self.create_test_files()
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
-        self.cmd(f'--repo={self.repository_location}::test', 'create', 'input', '--debug-profile=create.prof')
+        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', 'input', '--debug-profile=create.prof')
         self.cmd('debug', 'convert-profile', 'create.prof', 'create.pyprof')
         stats = pstats.Stats('create.pyprof')
         stats.strip_dirs()
         stats.sort_stats('cumtime')
 
-        self.cmd(f'--repo={self.repository_location}::test2', 'create', 'input', '--debug-profile=create.pyprof')
+        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test2', 'input', '--debug-profile=create.pyprof')
         stats = pstats.Stats('create.pyprof')  # Only do this on trusted data!
         stats.strip_dirs()
         stats.sort_stats('cumtime')
@@ -2437,7 +2439,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
     def test_common_options(self):
         self.create_test_files()
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
-        log = self.cmd(f'--repo={self.repository_location}::test', '--debug', 'create', 'input')
+        log = self.cmd(f'--repo={self.repository_location}', '--debug', 'create', '--name=test', 'input')
         assert 'security: read previous location' in log
 
     def test_change_passphrase(self):
@@ -2511,8 +2513,8 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
         self.create_test_files()
         have_noatime = has_noatime('input/file1')
-        self.cmd(f'--repo={self.repository_location}::archive', 'create', '--exclude-nodump', '--atime', 'input')
-        self.cmd(f'--repo={self.repository_location}::archive2', 'create', '--exclude-nodump', '--atime', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'create', '--name=archive', '--exclude-nodump', '--atime', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'create', '--name=archive2', '--exclude-nodump', '--atime', 'input')
         if has_lchflags:
             # remove the file we did not backup, so input and output become equal
             os.remove(os.path.join('input', 'flagfile'))
@@ -2526,7 +2528,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
             self.assert_dirs_equal(self.input_path, os.path.join(mountpoint, 'archive2', 'input'),
                                    ignore_flags=True, ignore_xattrs=True)
         # mount only 1 archive, its contents shall show up directly in mountpoint:
-        with self.fuse_mount(self.repository_location + '::archive', mountpoint):
+        with self.fuse_mount(self.repository_location, mountpoint, '--name=archive'):
             self.assert_dirs_equal(self.input_path, os.path.join(mountpoint, 'input'),
                                    ignore_flags=True, ignore_xattrs=True)
             # regular file
@@ -2604,9 +2606,9 @@ class ArchiverTestCase(ArchiverTestCaseBase):
             self.create_regular_file('hardlink1', contents=b'123456')
             os.link('input/hardlink1', 'input/hardlink2')
             os.link('input/hardlink1', 'input/hardlink3')
-        self.cmd(f'--repo={self.repository_location}::archive1', 'create', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'create', '--name=archive1', 'input')
         self.create_regular_file('test', contents=b'second')
-        self.cmd(f'--repo={self.repository_location}::archive2', 'create', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'create', '--name=archive2', 'input')
         mountpoint = os.path.join(self.tmpdir, 'mountpoint')
         # mount the whole repository, archive contents shall show up in versioned view:
         with self.fuse_mount(self.repository_location, mountpoint, '-o', 'versions'):
@@ -2646,11 +2648,11 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self.cmd(f'--repo={self.repository_location}', 'check', '--repair', exit_code=0)
 
         mountpoint = os.path.join(self.tmpdir, 'mountpoint')
-        with self.fuse_mount(self.repository_location + '::archive', mountpoint):
+        with self.fuse_mount(self.repository_location, mountpoint, '--name=archive'):
             with pytest.raises(OSError) as excinfo:
                 open(os.path.join(mountpoint, path))
             assert excinfo.value.errno == errno.EIO
-        with self.fuse_mount(self.repository_location + '::archive', mountpoint, '-o', 'allow_damaged_files'):
+        with self.fuse_mount(self.repository_location, mountpoint, '--name=archive', '-o', 'allow_damaged_files'):
             open(os.path.join(mountpoint, path)).close()
 
     @unittest.skipUnless(llfuse, 'llfuse not installed')
@@ -2784,11 +2786,11 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         os.environ['BORG_PASSPHRASE'] = 'passphrase'
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=' + method)
         verify_uniqueness()
-        self.cmd(f'--repo={self.repository_location}::test', 'create', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', 'input')
         verify_uniqueness()
-        self.cmd(f'--repo={self.repository_location}::test.2', 'create', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test.2', 'input')
         verify_uniqueness()
-        self.cmd(f'--repo={self.repository_location}::test.2', 'delete')
+        self.cmd(f'--repo={self.repository_location}', 'delete', '--name=test.2')
         verify_uniqueness()
 
     def test_aes_counter_uniqueness_keyfile(self):
@@ -2800,9 +2802,9 @@ class ArchiverTestCase(ArchiverTestCaseBase):
     def test_debug_dump_archive_items(self):
         self.create_test_files()
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
-        self.cmd(f'--repo={self.repository_location}::test', 'create', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', 'input')
         with changedir('output'):
-            output = self.cmd(f'--repo={self.repository_location}::test', 'debug', 'dump-archive-items')
+            output = self.cmd(f'--repo={self.repository_location}', 'debug', 'dump-archive-items', '--name=test')
         output_dir = sorted(os.listdir('output'))
         assert len(output_dir) > 0 and output_dir[0].startswith('000000_')
         assert 'Done.' in output
@@ -2810,7 +2812,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
     def test_debug_dump_repo_objs(self):
         self.create_test_files()
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
-        self.cmd(f'--repo={self.repository_location}::test', 'create', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', 'input')
         with changedir('output'):
             output = self.cmd(f'--repo={self.repository_location}', 'debug', 'dump-repo-objs')
         output_dir = sorted(os.listdir('output'))
@@ -2897,7 +2899,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
 
     def test_check_cache(self):
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
-        self.cmd(f'--repo={self.repository_location}::test', 'create', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', 'input')
         with self.open_repository() as repository:
             manifest, key = Manifest.load(repository, Manifest.NO_OPERATION_CHECK)
             with Cache(repository, key, manifest, sync=False) as cache:
@@ -2916,17 +2918,17 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self.create_test_files()
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
         self.check_cache()
-        self.cmd(f'--repo={self.repository_location}::test0', 'create', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test0', 'input')
         self.check_cache()
         original_archive = self.cmd(f'--repo={self.repository_location}', 'list')
-        self.cmd(f'--repo={self.repository_location}::test0', 'recreate', 'input/dir2',
+        self.cmd(f'--repo={self.repository_location}', 'recreate', '--name=test0', 'input/dir2',
                  '-e', 'input/dir2/file3', '--target=new-archive')
         self.check_cache()
         archives = self.cmd(f'--repo={self.repository_location}', 'list')
         assert original_archive in archives
         assert 'new-archive' in archives
 
-        listing = self.cmd(f'--repo={self.repository_location}::new-archive', 'list', '--short')
+        listing = self.cmd(f'--repo={self.repository_location}', 'list', '--name=new-archive', '--short')
         assert 'file1' not in listing
         assert 'dir2/file2' in listing
         assert 'dir2/file3' not in listing
@@ -2935,10 +2937,10 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self.create_test_files()
         self.create_regular_file('dir2/file3', size=1024 * 80)
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
-        self.cmd(f'--repo={self.repository_location}::test0', 'create', 'input')
-        self.cmd(f'--repo={self.repository_location}::test0', 'recreate', 'input/dir2', '-e', 'input/dir2/file3')
+        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test0', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'recreate', '--name=test0', 'input/dir2', '-e', 'input/dir2/file3')
         self.check_cache()
-        listing = self.cmd(f'--repo={self.repository_location}::test0', 'list', '--short')
+        listing = self.cmd(f'--repo={self.repository_location}', 'list', '--name=test0', '--short')
         assert 'file1' not in listing
         assert 'dir2/file2' in listing
         assert 'dir2/file3' not in listing
@@ -2947,17 +2949,17 @@ class ArchiverTestCase(ArchiverTestCaseBase):
     def test_recreate_subtree_hardlinks(self):
         # This is essentially the same problem set as in test_extract_hardlinks
         self._extract_hardlinks_setup()
-        self.cmd(f'--repo={self.repository_location}::test2', 'create', 'input')
-        self.cmd(f'--repo={self.repository_location}::test', 'recreate', 'input/dir1')
+        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test2', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'recreate', '--name=test', 'input/dir1')
         self.check_cache()
         with changedir('output'):
-            self.cmd(f'--repo={self.repository_location}::test', 'extract')
+            self.cmd(f'--repo={self.repository_location}', 'extract', '--name=test')
             assert os.stat('input/dir1/hardlink').st_nlink == 2
             assert os.stat('input/dir1/subdir/hardlink').st_nlink == 2
             assert os.stat('input/dir1/aaaa').st_nlink == 2
             assert os.stat('input/dir1/source2').st_nlink == 2
         with changedir('output'):
-            self.cmd(f'--repo={self.repository_location}::test2', 'extract')
+            self.cmd(f'--repo={self.repository_location}', 'extract', '--name=test2')
             assert os.stat('input/dir1/hardlink').st_nlink == 4
 
     def test_recreate_rechunkify(self):
@@ -2965,9 +2967,9 @@ class ArchiverTestCase(ArchiverTestCaseBase):
             fd.write(b'a' * 280)
             fd.write(b'b' * 280)
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
-        self.cmd(f'--repo={self.repository_location}::test1', 'create', '--chunker-params', '7,9,8,128', 'input')
-        self.cmd(f'--repo={self.repository_location}::test2', 'create', 'input', '--files-cache=disabled')
-        list = self.cmd(f'--repo={self.repository_location}::test1', 'list', 'input/large_file',
+        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test1', '--chunker-params', '7,9,8,128', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test2', 'input', '--files-cache=disabled')
+        list = self.cmd(f'--repo={self.repository_location}', 'list', '--name=test1', 'input/large_file',
                         '--format', '{num_chunks} {unique_chunks}')
         num_chunks, unique_chunks = map(int, list.split(' '))
         # test1 and test2 do not deduplicate
@@ -2975,20 +2977,20 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self.cmd(f'--repo={self.repository_location}', 'recreate', '--chunker-params', 'default')
         self.check_cache()
         # test1 and test2 do deduplicate after recreate
-        assert int(self.cmd(f'--repo={self.repository_location}::test1', 'list', 'input/large_file', '--format={size}'))
-        assert not int(self.cmd(f'--repo={self.repository_location}::test1', 'list', 'input/large_file',
+        assert int(self.cmd(f'--repo={self.repository_location}', 'list', '--name=test1', 'input/large_file', '--format={size}'))
+        assert not int(self.cmd(f'--repo={self.repository_location}', 'list', '--name=test1', 'input/large_file',
                                 '--format', '{unique_chunks}'))
 
     def test_recreate_recompress(self):
         self.create_regular_file('compressible', size=10000)
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
-        self.cmd(f'--repo={self.repository_location}::test', 'create', 'input', '-C', 'none')
-        file_list = self.cmd(f'--repo={self.repository_location}::test', 'list', 'input/compressible',
+        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', 'input', '-C', 'none')
+        file_list = self.cmd(f'--repo={self.repository_location}', 'list', '--name=test', 'input/compressible',
                              '--format', '{size} {sha256}')
         size, sha256_before = file_list.split(' ')
         self.cmd(f'--repo={self.repository_location}', 'recreate', '-C', 'lz4', '--recompress')
         self.check_cache()
-        file_list = self.cmd(f'--repo={self.repository_location}::test', 'list', 'input/compressible',
+        file_list = self.cmd(f'--repo={self.repository_location}', 'list', '--name=test', 'input/compressible',
                              '--format', '{size} {sha256}')
         size, sha256_after = file_list.split(' ')
         assert sha256_before == sha256_after
@@ -2997,10 +2999,10 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         local_timezone = datetime.now(timezone(timedelta(0))).astimezone().tzinfo
         self.create_test_files()
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
-        self.cmd(f'--repo={self.repository_location}::test0', 'create', 'input')
-        self.cmd(f'--repo={self.repository_location}::test0', 'recreate', '--timestamp', "1970-01-02T00:00:00",
+        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test0', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'recreate', '--name=test0', '--timestamp', "1970-01-02T00:00:00",
                  '--comment', 'test')
-        info = self.cmd(f'--repo={self.repository_location}::test0', 'info').splitlines()
+        info = self.cmd(f'--repo={self.repository_location}', 'info', '--name=test0').splitlines()
         dtime = datetime(1970, 1, 2) + local_timezone.utcoffset(None)
         s_time = dtime.strftime("%Y-%m-%d")
         assert any([re.search(r'Time \(start\).+ %s' % s_time, item) for item in info])
@@ -3009,21 +3011,21 @@ class ArchiverTestCase(ArchiverTestCaseBase):
     def test_recreate_dry_run(self):
         self.create_regular_file('compressible', size=10000)
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
-        self.cmd(f'--repo={self.repository_location}::test', 'create', 'input')
-        archives_before = self.cmd(f'--repo={self.repository_location}::test', 'list')
+        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', 'input')
+        archives_before = self.cmd(f'--repo={self.repository_location}', 'list', '--name=test')
         self.cmd(f'--repo={self.repository_location}', 'recreate', '-n', '-e', 'input/compressible')
         self.check_cache()
-        archives_after = self.cmd(f'--repo={self.repository_location}::test', 'list')
+        archives_after = self.cmd(f'--repo={self.repository_location}', 'list', '--name=test')
         assert archives_after == archives_before
 
     def test_recreate_skips_nothing_to_do(self):
         self.create_regular_file('file1', size=1024 * 80)
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
-        self.cmd(f'--repo={self.repository_location}::test', 'create', 'input')
-        info_before = self.cmd(f'--repo={self.repository_location}::test', 'info')
+        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', 'input')
+        info_before = self.cmd(f'--repo={self.repository_location}', 'info', '--name=test')
         self.cmd(f'--repo={self.repository_location}', 'recreate', '--chunker-params', 'default')
         self.check_cache()
-        info_after = self.cmd(f'--repo={self.repository_location}::test', 'info')
+        info_after = self.cmd(f'--repo={self.repository_location}', 'info', '--name=test')
         assert info_before == info_after  # includes archive ID
 
     def test_with_lock(self):
@@ -3040,31 +3042,31 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self.create_regular_file('file4', size=0)
         self.create_regular_file('file5', size=0)
 
-        self.cmd(f'--repo={self.repository_location}::test', 'create', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', 'input')
 
-        output = self.cmd(f'--repo={self.repository_location}::test', 'recreate', '--list', '--info', '-e', 'input/file2')
+        output = self.cmd(f'--repo={self.repository_location}', 'recreate', '--name=test', '--list', '--info', '-e', 'input/file2')
         self.check_cache()
         self.assert_in("input/file1", output)
         self.assert_in("x input/file2", output)
 
-        output = self.cmd(f'--repo={self.repository_location}::test', 'recreate', '--list', '-e', 'input/file3')
+        output = self.cmd(f'--repo={self.repository_location}', 'recreate', '--name=test', '--list', '-e', 'input/file3')
         self.check_cache()
         self.assert_in("input/file1", output)
         self.assert_in("x input/file3", output)
 
-        output = self.cmd(f'--repo={self.repository_location}::test', 'recreate', '-e', 'input/file4')
+        output = self.cmd(f'--repo={self.repository_location}', 'recreate', '--name=test', '-e', 'input/file4')
         self.check_cache()
         self.assert_not_in("input/file1", output)
         self.assert_not_in("x input/file4", output)
 
-        output = self.cmd(f'--repo={self.repository_location}::test', 'recreate', '--info', '-e', 'input/file5')
+        output = self.cmd(f'--repo={self.repository_location}', 'recreate', '--name=test', '--info', '-e', 'input/file5')
         self.check_cache()
         self.assert_not_in("input/file1", output)
         self.assert_not_in("x input/file5", output)
 
     def test_bad_filters(self):
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
-        self.cmd(f'--repo={self.repository_location}::test', 'create', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', 'input')
         self.cmd(f'--repo={self.repository_location}', 'delete', '--first', '1', '--last', '1', fork=True, exit_code=2)
 
     def test_key_export_keyfile(self):
@@ -3264,7 +3266,7 @@ id: 2 / e29442 3506da 4e1ea7 / 25f62a 5a3d41 - 02
     def test_debug_dump_manifest(self):
         self.create_regular_file('file1', size=1024 * 80)
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
-        self.cmd(f'--repo={self.repository_location}::test', 'create', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', 'input')
         dump_file = self.output_path + '/dump'
         output = self.cmd(f'--repo={self.repository_location}', 'debug', 'dump-manifest', dump_file)
         assert output == ""
@@ -3279,9 +3281,9 @@ id: 2 / e29442 3506da 4e1ea7 / 25f62a 5a3d41 - 02
     def test_debug_dump_archive(self):
         self.create_regular_file('file1', size=1024 * 80)
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
-        self.cmd(f'--repo={self.repository_location}::test', 'create', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', 'input')
         dump_file = self.output_path + '/dump'
-        output = self.cmd(f'--repo={self.repository_location}::test', 'debug', 'dump-archive', dump_file)
+        output = self.cmd(f'--repo={self.repository_location}', 'debug', 'dump-archive', '--name=test', dump_file)
         assert output == ""
         with open(dump_file) as f:
             result = json.load(f)
@@ -3295,7 +3297,7 @@ id: 2 / e29442 3506da 4e1ea7 / 25f62a 5a3d41 - 02
         output = self.cmd(f'--repo={self.repository_location}', 'debug', 'refcount-obj', '0' * 64).strip()
         assert output == 'object 0000000000000000000000000000000000000000000000000000000000000000 not found [info from chunks cache].'
 
-        create_json = json.loads(self.cmd(f'--repo={self.repository_location}::test', 'create', '--json', 'input'))
+        create_json = json.loads(self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', '--json', 'input'))
         archive_id = create_json['archive']['id']
         output = self.cmd(f'--repo={self.repository_location}', 'debug', 'refcount-obj', archive_id).strip()
         assert output == 'object ' + archive_id + ' has 1 referrers [info from chunks cache].'
@@ -3361,8 +3363,8 @@ id: 2 / e29442 3506da 4e1ea7 / 25f62a 5a3d41 - 02
         self.create_test_files()
         os.unlink('input/flagfile')
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
-        self.cmd(f'--repo={self.repository_location}::test', 'create', 'input')
-        self.cmd(f'--repo={self.repository_location}::test', 'export-tar', 'simple.tar', '--progress', '--tar-format=GNU')
+        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'export-tar', '--name=test', 'simple.tar', '--progress', '--tar-format=GNU')
         with changedir('output'):
             # This probably assumes GNU tar. Note -p switch to extract permissions regardless of umask.
             subprocess.check_call(['tar', 'xpf', '../simple.tar', '--warning=no-timestamp'])
@@ -3376,8 +3378,8 @@ id: 2 / e29442 3506da 4e1ea7 / 25f62a 5a3d41 - 02
         self.create_test_files()
         os.unlink('input/flagfile')
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
-        self.cmd(f'--repo={self.repository_location}::test', 'create', 'input')
-        list = self.cmd(f'--repo={self.repository_location}::test', 'export-tar', 'simple.tar.gz',
+        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', 'input')
+        list = self.cmd(f'--repo={self.repository_location}', 'export-tar', '--name=test', 'simple.tar.gz',
                         '--list', '--tar-format=GNU')
         assert 'input/file1\n' in list
         assert 'input/dir2\n' in list
@@ -3392,8 +3394,8 @@ id: 2 / e29442 3506da 4e1ea7 / 25f62a 5a3d41 - 02
         self.create_test_files()
         os.unlink('input/flagfile')
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
-        self.cmd(f'--repo={self.repository_location}::test', 'create', 'input')
-        list = self.cmd(f'--repo={self.repository_location}::test', 'export-tar', 'simple.tar',
+        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', 'input')
+        list = self.cmd(f'--repo={self.repository_location}', 'export-tar', '--name=test', 'simple.tar',
                         '--strip-components=1', '--list', '--tar-format=GNU')
         # --list's path are those before processing with --strip-components
         assert 'input/file1\n' in list
@@ -3406,7 +3408,7 @@ id: 2 / e29442 3506da 4e1ea7 / 25f62a 5a3d41 - 02
     @requires_gnutar
     def test_export_tar_strip_components_links(self):
         self._extract_hardlinks_setup()
-        self.cmd(f'--repo={self.repository_location}::test', 'export-tar', 'output.tar',
+        self.cmd(f'--repo={self.repository_location}', 'export-tar', '--name=test', 'output.tar',
                  '--strip-components=2', '--tar-format=GNU')
         with changedir('output'):
             subprocess.check_call(['tar', 'xpf', '../output.tar', '--warning=no-timestamp'])
@@ -3419,7 +3421,7 @@ id: 2 / e29442 3506da 4e1ea7 / 25f62a 5a3d41 - 02
     @requires_gnutar
     def test_extract_hardlinks_tar(self):
         self._extract_hardlinks_setup()
-        self.cmd(f'--repo={self.repository_location}::test', 'export-tar', 'output.tar', 'input/dir1', '--tar-format=GNU')
+        self.cmd(f'--repo={self.repository_location}', 'export-tar', '--name=test', 'output.tar', 'input/dir1', '--tar-format=GNU')
         with changedir('output'):
             subprocess.check_call(['tar', 'xpf', '../output.tar', '--warning=no-timestamp'])
             assert os.stat('input/dir1/hardlink').st_nlink == 2
@@ -3431,11 +3433,11 @@ id: 2 / e29442 3506da 4e1ea7 / 25f62a 5a3d41 - 02
         self.create_test_files(create_hardlinks=False)  # hardlinks become separate files
         os.unlink('input/flagfile')
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=none')
-        self.cmd(f'--repo={self.repository_location}::src', 'create', 'input')
-        self.cmd(f'--repo={self.repository_location}::src', 'export-tar', 'simple.tar', f'--tar-format={tar_format}')
-        self.cmd(f'--repo={self.repository_location}::dst', 'import-tar', 'simple.tar')
+        self.cmd(f'--repo={self.repository_location}', 'create', '--name=src', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'export-tar', '--name=src', 'simple.tar', f'--tar-format={tar_format}')
+        self.cmd(f'--repo={self.repository_location}', 'import-tar', '--name=dst', 'simple.tar')
         with changedir(self.output_path):
-            self.cmd(f'--repo={self.repository_location}::dst', 'extract')
+            self.cmd(f'--repo={self.repository_location}', 'extract', '--name=dst')
         self.assert_dirs_equal('input', 'output/input', ignore_ns=True, ignore_xattrs=True)
 
     @requires_gzip
@@ -3445,21 +3447,21 @@ id: 2 / e29442 3506da 4e1ea7 / 25f62a 5a3d41 - 02
         self.create_test_files(create_hardlinks=False)  # hardlinks become separate files
         os.unlink('input/flagfile')
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=none')
-        self.cmd(f'--repo={self.repository_location}::src', 'create', 'input')
-        self.cmd(f'--repo={self.repository_location}::src', 'export-tar', 'simple.tgz', f'--tar-format={tar_format}')
-        self.cmd(f'--repo={self.repository_location}::dst', 'import-tar', 'simple.tgz')
+        self.cmd(f'--repo={self.repository_location}', 'create', '--name=src', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'export-tar', '--name=src', 'simple.tgz', f'--tar-format={tar_format}')
+        self.cmd(f'--repo={self.repository_location}', 'import-tar', '--name=dst', 'simple.tgz')
         with changedir(self.output_path):
-            self.cmd(f'--repo={self.repository_location}::dst', 'extract')
+            self.cmd(f'--repo={self.repository_location}', 'extract', '--name=dst')
         self.assert_dirs_equal('input', 'output/input', ignore_ns=True, ignore_xattrs=True)
 
     def test_roundtrip_pax_borg(self):
         self.create_test_files()
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=none')
-        self.cmd(f'--repo={self.repository_location}::src', 'create', 'input')
-        self.cmd(f'--repo={self.repository_location}::src', 'export-tar', 'simple.tar', '--tar-format=BORG')
-        self.cmd(f'--repo={self.repository_location}::dst', 'import-tar', 'simple.tar')
+        self.cmd(f'--repo={self.repository_location}', 'create', '--name=src', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'export-tar', '--name=src', 'simple.tar', '--tar-format=BORG')
+        self.cmd(f'--repo={self.repository_location}', 'import-tar', '--name=dst', 'simple.tar')
         with changedir(self.output_path):
-            self.cmd(f'--repo={self.repository_location}::dst', 'extract')
+            self.cmd(f'--repo={self.repository_location}', 'extract', '--name=dst')
         self.assert_dirs_equal('input', 'output/input')
 
     # derived from test_extract_xattrs_errors()
@@ -3473,10 +3475,10 @@ id: 2 / e29442 3506da 4e1ea7 / 25f62a 5a3d41 - 02
         self.create_regular_file('file')
         xattr.setxattr(b'input/file', b'user.attribute%p', b'value')
         self.cmd('init', self.repository_location, '-e' 'none')
-        self.cmd('create', self.repository_location + '::test', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', 'input')
         with changedir('output'):
             with patch.object(xattr, 'setxattr', patched_setxattr_EACCES):
-                self.cmd('extract', self.repository_location + '::test', exit_code=EXIT_WARNING)
+                self.cmd(f'--repo={self.repository_location}', 'extract', '--name=test', exit_code=EXIT_WARNING)
 
     # derived from test_extract_xattrs_errors()
     @pytest.mark.skipif(not xattr.XATTR_FAKEROOT, reason='xattr not supported on this system or on this version of'
@@ -3489,14 +3491,14 @@ id: 2 / e29442 3506da 4e1ea7 / 25f62a 5a3d41 - 02
         os.makedirs(os.path.join(self.input_path, 'dir%p'))
         xattr.setxattr(b'input/dir%p', b'user.attribute', b'value')
         self.cmd(f'--repo={self.repository_location}', 'init', '-e' 'none')
-        self.cmd(f'--repo={self.repository_location}::test', 'create', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', 'input')
         with changedir('output'):
             with patch.object(xattr, 'setxattr', patched_setxattr_EACCES):
-                self.cmd(f'--repo={self.repository_location}::test', 'extract', exit_code=EXIT_WARNING)
+                self.cmd(f'--repo={self.repository_location}', 'extract', '--name=test', exit_code=EXIT_WARNING)
 
     def test_do_not_mention_archive_if_you_can_not_find_repo(self):
         """https://github.com/borgbackup/borg/issues/6014"""
-        output = self.cmd(f'--repo={self.repository_location}-this-repository-does-not-exist::test', 'info',
+        output = self.cmd(f'--repo={self.repository_location}-this-repository-does-not-exist', 'info', '--name=test',
                           exit_code=2, fork=True)
         self.assert_in('this-repository-does-not-exist', output)
         self.assert_not_in('this-repository-does-not-exist::test', output)
@@ -3508,7 +3510,7 @@ id: 2 / e29442 3506da 4e1ea7 / 25f62a 5a3d41 - 02
         both the client and the server forget the nonce"""
         self.create_regular_file('file1', contents=b'Hello, borg')
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
-        self.cmd(f'--repo={self.repository_location}::test', 'create', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', 'input')
         # Oops! We have removed the repo-side memory of the nonce!
         # See https://github.com/borgbackup/borg/issues/5858
         os.remove(os.path.join(self.repository_path, 'nonce'))
@@ -3521,13 +3523,13 @@ id: 2 / e29442 3506da 4e1ea7 / 25f62a 5a3d41 - 02
         repo_list = self.cmd(f'--repo={self.repository_location}', 'list')
         assert 'test' in repo_list
         # The archive should still be readable
-        archive_info = self.cmd(f'--repo={self.repository_location}::test', 'info')
+        archive_info = self.cmd(f'--repo={self.repository_location}', 'info', '--name=test')
         assert 'Archive name: test\n' in archive_info
-        archive_list = self.cmd(f'--repo={self.repository_location}::test', 'list')
+        archive_list = self.cmd(f'--repo={self.repository_location}', 'list', '--name=test')
         assert 'file1' in archive_list
         # Extracting the archive should work
         with changedir('output'):
-            self.cmd(f'--repo={self.repository_location}::test', 'extract')
+            self.cmd(f'--repo={self.repository_location}', 'extract', '--name=test')
         self.assert_dirs_equal('input', 'output/input')
 
     def test_recovery_from_deleted_repo_nonce(self):
@@ -3539,13 +3541,13 @@ id: 2 / e29442 3506da 4e1ea7 / 25f62a 5a3d41 - 02
         """
         self.create_regular_file('file1', contents=b'Hello, borg')
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
-        self.cmd(f'--repo={self.repository_location}::test', 'create', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', 'input')
         # Oops! We have removed the repo-side memory of the nonce!
         # See https://github.com/borgbackup/borg/issues/5858
         nonce = os.path.join(self.repository_path, 'nonce')
         os.remove(nonce)
 
-        self.cmd(f'--repo={self.repository_location}::test2', 'create', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test2', 'input')
         assert os.path.exists(nonce)
 
     def test_init_defaults_to_argon2(self):
@@ -3696,7 +3698,7 @@ class ArchiverCheckTestCase(ArchiverTestCaseBase):
         output = self.cmd(f'--repo={self.repository_location}', 'check', '--repair', exit_code=0)
         self.assert_in('New missing file chunk detected', output)
         self.cmd(f'--repo={self.repository_location}', 'check', exit_code=0)
-        output = self.cmd(f'--repo={self.repository_location}::archive1', 'list', '--format={health}#{path}{LF}', exit_code=0)
+        output = self.cmd(f'--repo={self.repository_location}', 'list', '--name=archive1', '--format={health}#{path}{LF}', exit_code=0)
         self.assert_in('broken#', output)
         # check that the file in the old archives has now a different chunk list without the killed chunk
         for archive_name in ('archive1', 'archive2'):
@@ -3727,7 +3729,7 @@ class ArchiverCheckTestCase(ArchiverTestCaseBase):
                 else:
                     self.fail('should not happen')
         # list is also all-healthy again
-        output = self.cmd(f'--repo={self.repository_location}::archive1', 'list', '--format={health}#{path}{LF}', exit_code=0)
+        output = self.cmd(f'--repo={self.repository_location}', 'list', '--name=archive1', '--format={health}#{path}{LF}', exit_code=0)
         self.assert_not_in('broken#', output)
 
     def test_missing_archive_item_chunk(self):
@@ -3824,7 +3826,7 @@ class ArchiverCheckTestCase(ArchiverTestCaseBase):
         self.cmd(f'--repo={self.repository_location}', 'check', exit_code=1)
         self.cmd(f'--repo={self.repository_location}', 'check', '--repair', exit_code=0)
         self.cmd(f'--repo={self.repository_location}', 'check', exit_code=0)
-        self.cmd(f'--repo={self.repository_location}::archive1', 'extract', '--dry-run', exit_code=0)
+        self.cmd(f'--repo={self.repository_location}', 'extract', '--name=archive1', '--dry-run', exit_code=0)
 
     def _test_verify_data(self, *init_args):
         shutil.rmtree(self.repository_path)
@@ -3992,19 +3994,19 @@ class RemoteArchiverTestCase(ArchiverTestCase):
         self.create_regular_file('skipped-file1', contents=b"test file contents 3")
         self.create_regular_file('skipped-file2', contents=b"test file contents 4")
         self.create_regular_file('skipped-file3', contents=b"test file contents 5")
-        self.cmd(f'--repo={self.repository_location}::test', 'create', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', 'input')
         marker = 'cached responses left in RemoteRepository'
         with changedir('output'):
-            res = self.cmd(f'--repo={self.repository_location}::test', 'extract', "--debug", '--strip-components', '3')
+            res = self.cmd(f'--repo={self.repository_location}', 'extract', '--name=test', "--debug", '--strip-components', '3')
             assert marker not in res
             with self.assert_creates_file('file'):
-                res = self.cmd(f'--repo={self.repository_location}::test', 'extract', "--debug", '--strip-components', '2')
+                res = self.cmd(f'--repo={self.repository_location}', 'extract', '--name=test', "--debug", '--strip-components', '2')
                 assert marker not in res
             with self.assert_creates_file('dir/file'):
-                res = self.cmd(f'--repo={self.repository_location}::test', 'extract', "--debug", '--strip-components', '1')
+                res = self.cmd(f'--repo={self.repository_location}', 'extract', '--name=test', "--debug", '--strip-components', '1')
                 assert marker not in res
             with self.assert_creates_file('input/dir/file'):
-                res = self.cmd(f'--repo={self.repository_location}::test', 'extract', "--debug", '--strip-components', '0')
+                res = self.cmd(f'--repo={self.repository_location}', 'extract', '--name=test', "--debug", '--strip-components', '0')
                 assert marker not in res
 
 
@@ -4033,17 +4035,17 @@ class ArchiverCorruptionTestCase(ArchiverTestCaseBase):
                 self.cmd(f'--repo={self.repository_location}', 'info')
 
     def test_cache_files(self):
-        self.cmd(f'--repo={self.repository_location}::test', 'create', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', 'input')
         self.corrupt(os.path.join(self.cache_path, 'files'))
-        out = self.cmd(f'--repo={self.repository_location}::test1', 'create', 'input')
+        out = self.cmd(f'--repo={self.repository_location}', 'create', '--name=test1', 'input')
         # borg warns about the corrupt files cache, but then continues without files cache.
         assert 'files cache is corrupted' in out
 
     def test_chunks_archive(self):
-        self.cmd(f'--repo={self.repository_location}::test1', 'create', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test1', 'input')
         # Find ID of test1 so we can corrupt it later :)
         target_id = self.cmd(f'--repo={self.repository_location}', 'list', '--format={id}{LF}').strip()
-        self.cmd(f'--repo={self.repository_location}::test2', 'create', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test2', 'input')
 
         # Force cache sync, creating archive chunks of test1 and test2 in chunks.archive.d
         self.cmd(f'--repo={self.repository_location}', 'delete', '--cache-only')
@@ -4063,7 +4065,7 @@ class ArchiverCorruptionTestCase(ArchiverTestCaseBase):
             config.write(fd)
 
         # Cache sync notices corrupted archive chunks, but automatically recovers.
-        out = self.cmd(f'--repo={self.repository_location}::test3', 'create', '-v', 'input', exit_code=1)
+        out = self.cmd(f'--repo={self.repository_location}', 'create', '--name=test3', '-v', 'input', exit_code=1)
         assert 'Reading cached archive chunk index for test1' in out
         assert 'Cached archive chunk index of test1 is corrupted' in out
         assert 'Fetching and building archive index for test1' in out
@@ -4109,7 +4111,7 @@ class DiffArchiverTestCase(ArchiverTestCaseBase):
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
 
         # Create the first snapshot
-        self.cmd(f'--repo={self.repository_location}::test0', 'create', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test0', 'input')
 
         # Setup files for the second snapshot
         self.create_regular_file('file_added', size=2048)
@@ -4140,8 +4142,8 @@ class DiffArchiverTestCase(ArchiverTestCaseBase):
             fd.write(b'appended_data')
 
         # Create the second snapshot
-        self.cmd(f'--repo={self.repository_location}::test1a', 'create', 'input')
-        self.cmd(f'--repo={self.repository_location}::test1b', 'create', '--chunker-params', '16,18,17,4095', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test1a', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test1b', '--chunker-params', '16,18,17,4095', 'input')
 
         def do_asserts(output, can_compare_ids):
             # File contents changed (deleted and replaced with a new file)
@@ -4286,10 +4288,10 @@ class DiffArchiverTestCase(ArchiverTestCaseBase):
             if are_hardlinks_supported():
                 assert not any(get_changes('input/hardlink_target_replaced', joutput))
 
-        do_asserts(self.cmd(f'--repo={self.repository_location}::test0', 'diff', 'TODO_test0', 'test1a'), True)
+        do_asserts(self.cmd(f'--repo={self.repository_location}', 'diff', '--name=test0', '--name2=test1a'), True)
         # We expect exit_code=1 due to the chunker params warning
-        do_asserts(self.cmd(f'--repo={self.repository_location}::test0', 'diff', 'TODO_test0', 'test1b', exit_code=1), False)
-        do_json_asserts(self.cmd(f'--repo={self.repository_location}::test0', 'diff', 'TODO_test0', 'test1a', '--json-lines'), True)
+        do_asserts(self.cmd(f'--repo={self.repository_location}', 'diff', '--name=test0', '--name2=test1b', exit_code=1), False)
+        do_json_asserts(self.cmd(f'--repo={self.repository_location}', 'diff', '--name=test0', '--name2=test1a', '--json-lines'), True)
 
     def test_sort_option(self):
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
@@ -4298,7 +4300,7 @@ class DiffArchiverTestCase(ArchiverTestCaseBase):
         self.create_regular_file('f_file_removed', size=16)
         self.create_regular_file('c_file_changed', size=32)
         self.create_regular_file('e_file_changed', size=64)
-        self.cmd(f'--repo={self.repository_location}::test0', 'create', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test0', 'input')
 
         os.unlink('input/a_file_removed')
         os.unlink('input/f_file_removed')
@@ -4308,9 +4310,10 @@ class DiffArchiverTestCase(ArchiverTestCaseBase):
         self.create_regular_file('e_file_changed', size=1024)
         self.create_regular_file('b_file_added', size=128)
         self.create_regular_file('d_file_added', size=256)
-        self.cmd(f'--repo={self.repository_location}::test1', 'create', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test1', 'input')
 
-        output = self.cmd(f'--repo={self.repository_location}::test0', 'diff', '--sort', 'TODO_test0', 'test1')
+        output = self.cmd(f'--repo={self.repository_location}', 'diff', '--name=test0', '--name2=test1',
+                          '--sort')
         expected = [
             'a_file_removed',
             'b_file_added',
diff --git a/src/borg/testsuite/benchmark.py b/src/borg/testsuite/benchmark.py
index f3ec06f2a..4eb3a3da6 100644
--- a/src/borg/testsuite/benchmark.py
+++ b/src/borg/testsuite/benchmark.py
@@ -28,7 +28,7 @@ def repo_url(request, tmpdir, monkeypatch):
 
 @pytest.fixture(params=["none", "repokey"])
 def repo(request, cmd, repo_url):
-    cmd('init', '--encryption', request.param, repo_url)
+    cmd(f'--repo={repo_url}', 'init', '--encryption', request.param)
     return repo_url
 
 
@@ -55,46 +55,52 @@ def testdata(request, tmpdir_factory):
 
 
 @pytest.fixture(params=['none', 'lz4'])
-def archive(request, cmd, repo, testdata):
-    archive_url = repo + '::test'
-    cmd('create', '--compression', request.param, archive_url, testdata)
-    return archive_url
+def repo_archive(request, cmd, repo, testdata):
+    archive = 'test'
+    cmd(f'--repo={repo}', 'create', f'--name={archive}', '--compression', request.param, testdata)
+    return repo, archive
 
 
 def test_create_none(benchmark, cmd, repo, testdata):
-    result, out = benchmark.pedantic(cmd, ('create', '--compression', 'none', repo + '::test', testdata))
+    result, out = benchmark.pedantic(cmd, (f'--repo={repo}', 'create', '--compression', 'none',
+                                           '--name', 'test', testdata))
     assert result == 0
 
 
 def test_create_lz4(benchmark, cmd, repo, testdata):
-    result, out = benchmark.pedantic(cmd, ('create', '--compression', 'lz4', repo + '::test', testdata))
+    result, out = benchmark.pedantic(cmd, (f'--repo={repo}', 'create', '--compression', 'lz4',
+                                           '--name', 'test', testdata))
     assert result == 0
 
 
-def test_extract(benchmark, cmd, archive, tmpdir):
+def test_extract(benchmark, cmd, repo_archive, tmpdir):
+    repo, archive = repo_archive
     with changedir(str(tmpdir)):
-        result, out = benchmark.pedantic(cmd, ('extract', archive))
+        result, out = benchmark.pedantic(cmd, (f'--repo={repo}', 'extract', '--name', archive))
     assert result == 0
 
 
-def test_delete(benchmark, cmd, archive):
-    result, out = benchmark.pedantic(cmd, ('delete', archive))
+def test_delete(benchmark, cmd, repo_archive):
+    repo, archive = repo_archive
+    result, out = benchmark.pedantic(cmd, (f'--repo={repo}', 'delete', '--name', archive))
     assert result == 0
 
 
-def test_list(benchmark, cmd, archive):
-    result, out = benchmark(cmd, 'list', archive)
+def test_list(benchmark, cmd, repo_archive):
+    repo, archive = repo_archive
+    result, out = benchmark(cmd, f'--repo={repo}', 'list', '--name', archive)
     assert result == 0
 
 
-def test_info(benchmark, cmd, archive):
-    result, out = benchmark(cmd, 'info', archive)
+def test_info(benchmark, cmd, repo_archive):
+    repo, archive = repo_archive
+    result, out = benchmark(cmd, f'--repo={repo}', 'info', '--name', archive)
     assert result == 0
 
 
-def test_check(benchmark, cmd, archive):
-    repo = archive.split('::')[0]
-    result, out = benchmark(cmd, 'check', repo)
+def test_check(benchmark, cmd, repo_archive):
+    repo, archive = repo_archive
+    result, out = benchmark(cmd, f'--repo={repo}', 'check')
     assert result == 0
 
 

From 7dbf125083afc80714255233038210ab3c7ac72b Mon Sep 17 00:00:00 2001
From: Thomas Waldmann <tw@waldmann-edv.de>
Date: Thu, 16 Jun 2022 00:58:21 +0200
Subject: [PATCH 051/160] Location: remove archive name

---
 src/borg/archiver.py            |   2 +-
 src/borg/helpers/parseformat.py |  41 +++-------
 src/borg/testsuite/helpers.py   | 129 +++++++++++++-------------------
 3 files changed, 60 insertions(+), 112 deletions(-)

diff --git a/src/borg/archiver.py b/src/borg/archiver.py
index 2e112fafe..62636c1a0 100644
--- a/src/borg/archiver.py
+++ b/src/borg/archiver.py
@@ -116,7 +116,7 @@ def argument(args, str_or_bool):
 def get_repository(location, *, create, exclusive, lock_wait, lock, append_only,
                    make_parent_dirs, storage_quota, args):
     if location.proto == 'ssh':
-        repository = RemoteRepository(location.omit_archive(), create=create, exclusive=exclusive,
+        repository = RemoteRepository(location, create=create, exclusive=exclusive,
                                       lock_wait=lock_wait, lock=lock, append_only=append_only,
                                       make_parent_dirs=make_parent_dirs, args=args)
 
diff --git a/src/borg/helpers/parseformat.py b/src/borg/helpers/parseformat.py
index ab420dea7..808466776 100644
--- a/src/borg/helpers/parseformat.py
+++ b/src/borg/helpers/parseformat.py
@@ -301,9 +301,7 @@ def parse_stringified_list(s):
 
 
 class Location:
-    """Object representing a repository / archive location
-    """
-    proto = user = _host = port = path = archive = None
+    """Object representing a repository location"""
 
     # user must not contain "@", ":" or "/".
     # Quoting adduser error message:
@@ -335,15 +333,6 @@ class Location:
         (?P<path>(/([^:]|(:(?!:)))+))                       # start with /, then any chars, but no "::"
         """
 
-    # optional ::archive_name at the end, archive name must not contain "/".
-    # borg mount's FUSE filesystem creates one level of directories from
-    # the archive names and of course "/" is not valid in a directory name.
-    optional_archive_re = r"""
-        (?:
-            ::                                              # "::" as separator
-            (?P<archive>[^/]+)                              # archive name must not contain "/"
-        )?$"""                                              # must match until the end
-
     # host NAME, or host IP ADDRESS (v4 or v6, v6 must be in square brackets)
     host_re = r"""
         (?P<host>(
@@ -358,14 +347,13 @@ class Location:
         (?P<proto>ssh)://                                       # ssh://
         """ + optional_user_re + host_re + r"""                 # user@  (optional), host name or address
         (?::(?P<port>\d+))?                                     # :port (optional)
-        """ + abs_path_re + optional_archive_re, re.VERBOSE)    # path or path::archive
+        """ + abs_path_re, re.VERBOSE)                          # path
 
     file_re = re.compile(r"""
         (?P<proto>file)://                                      # file://
-        """ + file_path_re + optional_archive_re, re.VERBOSE)   # servername/path, path or path::archive
+        """ + file_path_re, re.VERBOSE)                         # servername/path or path
 
-    local_re = re.compile(
-        local_path_re + optional_archive_re, re.VERBOSE)    # local path with optional archive
+    local_re = re.compile(local_path_re, re.VERBOSE)            # local path
 
     win_file_re = re.compile(r"""
         (?:file://)?                                        # optional file protocol
@@ -373,7 +361,7 @@ class Location:
             (?:[a-zA-Z]:)?                                  # Drive letter followed by a colon (optional)
             (?:[^:]+)                                       # Anything which does not contain a :, at least one character
         )
-        """ + optional_archive_re, re.VERBOSE)              # archive name (optional, may be empty)
+        """, re.VERBOSE)
 
     def __init__(self, text='', overrides={}, other=False):
         self.repo_env_var = 'BORG_OTHER_REPO' if other else 'BORG_REPO'
@@ -383,7 +371,8 @@ class Location:
         self._host = None
         self.port = None
         self.path = None
-        self.archive = None
+        self.raw = None
+        self.processed = None
         self.parse(text, overrides)
 
     def parse(self, text, overrides={}):
@@ -413,10 +402,9 @@ class Location:
             if m:
                 self.proto = 'file'
                 self.path = m.group('path')
-                self.archive = m.group('archive')
                 return True
 
-            # On windows we currently only support windows paths
+            # On windows we currently only support windows paths.
             return False
 
         m = self.ssh_re.match(text)
@@ -426,19 +414,16 @@ class Location:
             self._host = m.group('host')
             self.port = m.group('port') and int(m.group('port')) or None
             self.path = normpath_special(m.group('path'))
-            self.archive = m.group('archive')
             return True
         m = self.file_re.match(text)
         if m:
             self.proto = m.group('proto')
             self.path = normpath_special(m.group('path'))
-            self.archive = m.group('archive')
             return True
         m = self.local_re.match(text)
         if m:
-            self.path = normpath_special(m.group('path'))
-            self.archive = m.group('archive')
             self.proto = 'file'
+            self.path = normpath_special(m.group('path'))
             return True
         return False
 
@@ -449,7 +434,6 @@ class Location:
             'host=%r' % self.host,
             'port=%r' % self.port,
             'path=%r' % self.path,
-            'archive=%r' % self.archive,
         ]
         return ', '.join(items)
 
@@ -494,13 +478,6 @@ class Location:
             'utcnow': DatetimeWrapper(timestamp),
         })
 
-    def omit_archive(self):
-        loc = Location(self.raw)
-        loc.archive = None
-        loc.raw = loc.raw.split("::")[0]
-        loc.processed = loc.processed.split("::")[0]
-        return loc
-
 
 def location_validator(proto=None, other=False):
     def validator(text):
diff --git a/src/borg/testsuite/helpers.py b/src/borg/testsuite/helpers.py
index 81469a133..52bbd207b 100644
--- a/src/borg/testsuite/helpers.py
+++ b/src/borg/testsuite/helpers.py
@@ -54,65 +54,63 @@ class TestLocationWithoutEnv:
 
     def test_ssh(self, monkeypatch, keys_dir):
         monkeypatch.delenv('BORG_REPO', raising=False)
-        assert repr(Location('ssh://user@host:1234/some/path::archive')) == \
-            "Location(proto='ssh', user='user', host='host', port=1234, path='/some/path', archive='archive')"
-        assert Location('ssh://user@host:1234/some/path::archive').to_key_filename() == keys_dir + 'host__some_path'
         assert repr(Location('ssh://user@host:1234/some/path')) == \
-            "Location(proto='ssh', user='user', host='host', port=1234, path='/some/path', archive=None)"
+            "Location(proto='ssh', user='user', host='host', port=1234, path='/some/path')"
+        assert Location('ssh://user@host:1234/some/path').to_key_filename() == keys_dir + 'host__some_path'
+        assert repr(Location('ssh://user@host:1234/some/path')) == \
+            "Location(proto='ssh', user='user', host='host', port=1234, path='/some/path')"
         assert repr(Location('ssh://user@host/some/path')) == \
-            "Location(proto='ssh', user='user', host='host', port=None, path='/some/path', archive=None)"
-        assert repr(Location('ssh://user@[::]:1234/some/path::archive')) == \
-            "Location(proto='ssh', user='user', host='::', port=1234, path='/some/path', archive='archive')"
+            "Location(proto='ssh', user='user', host='host', port=None, path='/some/path')"
         assert repr(Location('ssh://user@[::]:1234/some/path')) == \
-            "Location(proto='ssh', user='user', host='::', port=1234, path='/some/path', archive=None)"
+            "Location(proto='ssh', user='user', host='::', port=1234, path='/some/path')"
+        assert repr(Location('ssh://user@[::]:1234/some/path')) == \
+            "Location(proto='ssh', user='user', host='::', port=1234, path='/some/path')"
         assert Location('ssh://user@[::]:1234/some/path').to_key_filename() == keys_dir + '____some_path'
         assert repr(Location('ssh://user@[::]/some/path')) == \
-            "Location(proto='ssh', user='user', host='::', port=None, path='/some/path', archive=None)"
-        assert repr(Location('ssh://user@[2001:db8::]:1234/some/path::archive')) == \
-            "Location(proto='ssh', user='user', host='2001:db8::', port=1234, path='/some/path', archive='archive')"
+            "Location(proto='ssh', user='user', host='::', port=None, path='/some/path')"
         assert repr(Location('ssh://user@[2001:db8::]:1234/some/path')) == \
-            "Location(proto='ssh', user='user', host='2001:db8::', port=1234, path='/some/path', archive=None)"
+            "Location(proto='ssh', user='user', host='2001:db8::', port=1234, path='/some/path')"
+        assert repr(Location('ssh://user@[2001:db8::]:1234/some/path')) == \
+            "Location(proto='ssh', user='user', host='2001:db8::', port=1234, path='/some/path')"
         assert Location('ssh://user@[2001:db8::]:1234/some/path').to_key_filename() == keys_dir + '2001_db8____some_path'
         assert repr(Location('ssh://user@[2001:db8::]/some/path')) == \
-            "Location(proto='ssh', user='user', host='2001:db8::', port=None, path='/some/path', archive=None)"
-        assert repr(Location('ssh://user@[2001:db8::c0:ffee]:1234/some/path::archive')) == \
-            "Location(proto='ssh', user='user', host='2001:db8::c0:ffee', port=1234, path='/some/path', archive='archive')"
+            "Location(proto='ssh', user='user', host='2001:db8::', port=None, path='/some/path')"
         assert repr(Location('ssh://user@[2001:db8::c0:ffee]:1234/some/path')) == \
-            "Location(proto='ssh', user='user', host='2001:db8::c0:ffee', port=1234, path='/some/path', archive=None)"
+            "Location(proto='ssh', user='user', host='2001:db8::c0:ffee', port=1234, path='/some/path')"
+        assert repr(Location('ssh://user@[2001:db8::c0:ffee]:1234/some/path')) == \
+            "Location(proto='ssh', user='user', host='2001:db8::c0:ffee', port=1234, path='/some/path')"
         assert repr(Location('ssh://user@[2001:db8::c0:ffee]/some/path')) == \
-            "Location(proto='ssh', user='user', host='2001:db8::c0:ffee', port=None, path='/some/path', archive=None)"
-        assert repr(Location('ssh://user@[2001:db8::192.0.2.1]:1234/some/path::archive')) == \
-            "Location(proto='ssh', user='user', host='2001:db8::192.0.2.1', port=1234, path='/some/path', archive='archive')"
+            "Location(proto='ssh', user='user', host='2001:db8::c0:ffee', port=None, path='/some/path')"
         assert repr(Location('ssh://user@[2001:db8::192.0.2.1]:1234/some/path')) == \
-            "Location(proto='ssh', user='user', host='2001:db8::192.0.2.1', port=1234, path='/some/path', archive=None)"
+            "Location(proto='ssh', user='user', host='2001:db8::192.0.2.1', port=1234, path='/some/path')"
+        assert repr(Location('ssh://user@[2001:db8::192.0.2.1]:1234/some/path')) == \
+            "Location(proto='ssh', user='user', host='2001:db8::192.0.2.1', port=1234, path='/some/path')"
         assert repr(Location('ssh://user@[2001:db8::192.0.2.1]/some/path')) == \
-            "Location(proto='ssh', user='user', host='2001:db8::192.0.2.1', port=None, path='/some/path', archive=None)"
+            "Location(proto='ssh', user='user', host='2001:db8::192.0.2.1', port=None, path='/some/path')"
         assert Location('ssh://user@[2001:db8::192.0.2.1]/some/path').to_key_filename() == keys_dir + '2001_db8__192_0_2_1__some_path'
         assert repr(Location('ssh://user@[2a02:0001:0002:0003:0004:0005:0006:0007]/some/path')) == \
-            "Location(proto='ssh', user='user', host='2a02:0001:0002:0003:0004:0005:0006:0007', port=None, path='/some/path', archive=None)"
+            "Location(proto='ssh', user='user', host='2a02:0001:0002:0003:0004:0005:0006:0007', port=None, path='/some/path')"
         assert repr(Location('ssh://user@[2a02:0001:0002:0003:0004:0005:0006:0007]:1234/some/path')) == \
-            "Location(proto='ssh', user='user', host='2a02:0001:0002:0003:0004:0005:0006:0007', port=1234, path='/some/path', archive=None)"
+            "Location(proto='ssh', user='user', host='2a02:0001:0002:0003:0004:0005:0006:0007', port=1234, path='/some/path')"
 
     def test_file(self, monkeypatch, keys_dir):
         monkeypatch.delenv('BORG_REPO', raising=False)
-        assert repr(Location('file:///some/path::archive')) == \
-            "Location(proto='file', user=None, host=None, port=None, path='/some/path', archive='archive')"
         assert repr(Location('file:///some/path')) == \
-            "Location(proto='file', user=None, host=None, port=None, path='/some/path', archive=None)"
+            "Location(proto='file', user=None, host=None, port=None, path='/some/path')"
+        assert repr(Location('file:///some/path')) == \
+            "Location(proto='file', user=None, host=None, port=None, path='/some/path')"
         assert Location('file:///some/path').to_key_filename() == keys_dir + 'some_path'
 
     def test_smb(self, monkeypatch, keys_dir):
         monkeypatch.delenv('BORG_REPO', raising=False)
-        assert repr(Location('file:////server/share/path::archive')) == \
-            "Location(proto='file', user=None, host=None, port=None, path='//server/share/path', archive='archive')"
-        assert Location('file:////server/share/path::archive').to_key_filename() == keys_dir + 'server_share_path'
+        assert repr(Location('file:////server/share/path')) == \
+            "Location(proto='file', user=None, host=None, port=None, path='//server/share/path')"
+        assert Location('file:////server/share/path').to_key_filename() == keys_dir + 'server_share_path'
 
     def test_folder(self, monkeypatch, keys_dir):
         monkeypatch.delenv('BORG_REPO', raising=False)
-        assert repr(Location('path::archive')) == \
-            "Location(proto='file', user=None, host=None, port=None, path='path', archive='archive')"
         assert repr(Location('path')) == \
-            "Location(proto='file', user=None, host=None, port=None, path='path', archive=None)"
+            "Location(proto='file', user=None, host=None, port=None, path='path')"
         assert Location('path').to_key_filename() == keys_dir + 'path'
 
     def test_long_path(self, monkeypatch, keys_dir):
@@ -121,88 +119,61 @@ class TestLocationWithoutEnv:
 
     def test_abspath(self, monkeypatch, keys_dir):
         monkeypatch.delenv('BORG_REPO', raising=False)
-        assert repr(Location('/some/absolute/path::archive')) == \
-            "Location(proto='file', user=None, host=None, port=None, path='/some/absolute/path', archive='archive')"
         assert repr(Location('/some/absolute/path')) == \
-            "Location(proto='file', user=None, host=None, port=None, path='/some/absolute/path', archive=None)"
+            "Location(proto='file', user=None, host=None, port=None, path='/some/absolute/path')"
+        assert repr(Location('/some/absolute/path')) == \
+            "Location(proto='file', user=None, host=None, port=None, path='/some/absolute/path')"
         assert Location('/some/absolute/path').to_key_filename() == keys_dir + 'some_absolute_path'
         assert repr(Location('ssh://user@host/some/path')) == \
-               "Location(proto='ssh', user='user', host='host', port=None, path='/some/path', archive=None)"
+               "Location(proto='ssh', user='user', host='host', port=None, path='/some/path')"
         assert Location('ssh://user@host/some/path').to_key_filename() == keys_dir + 'host__some_path'
 
     def test_relpath(self, monkeypatch, keys_dir):
         monkeypatch.delenv('BORG_REPO', raising=False)
-        assert repr(Location('some/relative/path::archive')) == \
-            "Location(proto='file', user=None, host=None, port=None, path='some/relative/path', archive='archive')"
         assert repr(Location('some/relative/path')) == \
-            "Location(proto='file', user=None, host=None, port=None, path='some/relative/path', archive=None)"
+            "Location(proto='file', user=None, host=None, port=None, path='some/relative/path')"
+        assert repr(Location('some/relative/path')) == \
+            "Location(proto='file', user=None, host=None, port=None, path='some/relative/path')"
         assert Location('some/relative/path').to_key_filename() == keys_dir + 'some_relative_path'
         assert repr(Location('ssh://user@host/./some/path')) == \
-               "Location(proto='ssh', user='user', host='host', port=None, path='/./some/path', archive=None)"
+               "Location(proto='ssh', user='user', host='host', port=None, path='/./some/path')"
         assert Location('ssh://user@host/./some/path').to_key_filename() == keys_dir + 'host__some_path'
         assert repr(Location('ssh://user@host/~/some/path')) == \
-               "Location(proto='ssh', user='user', host='host', port=None, path='/~/some/path', archive=None)"
+               "Location(proto='ssh', user='user', host='host', port=None, path='/~/some/path')"
         assert Location('ssh://user@host/~/some/path').to_key_filename() == keys_dir + 'host__some_path'
         assert repr(Location('ssh://user@host/~user/some/path')) == \
-               "Location(proto='ssh', user='user', host='host', port=None, path='/~user/some/path', archive=None)"
+               "Location(proto='ssh', user='user', host='host', port=None, path='/~user/some/path')"
         assert Location('ssh://user@host/~user/some/path').to_key_filename() == keys_dir + 'host__user_some_path'
 
     def test_with_colons(self, monkeypatch, keys_dir):
         monkeypatch.delenv('BORG_REPO', raising=False)
-        assert repr(Location('/abs/path:w:cols::arch:col')) == \
-            "Location(proto='file', user=None, host=None, port=None, path='/abs/path:w:cols', archive='arch:col')"
-        assert repr(Location('/abs/path:with:colons::archive')) == \
-            "Location(proto='file', user=None, host=None, port=None, path='/abs/path:with:colons', archive='archive')"
+        assert repr(Location('/abs/path:w:cols')) == \
+            "Location(proto='file', user=None, host=None, port=None, path='/abs/path:w:cols')"
         assert repr(Location('/abs/path:with:colons')) == \
-            "Location(proto='file', user=None, host=None, port=None, path='/abs/path:with:colons', archive=None)"
+            "Location(proto='file', user=None, host=None, port=None, path='/abs/path:with:colons')"
+        assert repr(Location('/abs/path:with:colons')) == \
+            "Location(proto='file', user=None, host=None, port=None, path='/abs/path:with:colons')"
         assert Location('/abs/path:with:colons').to_key_filename() == keys_dir + 'abs_path_with_colons'
 
     def test_user_parsing(self):
         # see issue #1930
-        assert repr(Location('ssh://host/path::2016-12-31@23:59:59')) == \
-            "Location(proto='ssh', user=None, host='host', port=None, path='/path', archive='2016-12-31@23:59:59')"
-
-    def test_with_timestamp(self):
-        assert repr(Location('path::archive-{utcnow}').with_timestamp(datetime(2002, 9, 19, tzinfo=timezone.utc))) == \
-            "Location(proto='file', user=None, host=None, port=None, path='path', archive='archive-2002-09-19T00:00:00')"
-
-    def test_no_slashes(self, monkeypatch):
-        monkeypatch.delenv('BORG_REPO', raising=False)
-        with pytest.raises(ValueError):
-            Location('/some/path/to/repo::archive_name_with/slashes/is_invalid')
+        assert repr(Location('ssh://host/path')) == \
+            "Location(proto='ssh', user=None, host='host', port=None, path='/path')"
 
     def test_canonical_path(self, monkeypatch):
         monkeypatch.delenv('BORG_REPO', raising=False)
-        locations = ['some/path::archive', 'file://some/path::archive', 'host:some/path::archive',
-                     'host:~user/some/path::archive', 'ssh://host/some/path::archive',
-                     'ssh://user@host:1234/some/path::archive']
+        locations = ['some/path', 'file://some/path', 'host:some/path',
+                     'host:~user/some/path', 'ssh://host/some/path',
+                     'ssh://user@host:1234/some/path']
         for location in locations:
             assert Location(location).canonical_path() == \
                 Location(Location(location).canonical_path()).canonical_path(), "failed: %s" % location
 
-    def test_format_path(self, monkeypatch):
-        monkeypatch.delenv('BORG_REPO', raising=False)
-        test_pid = os.getpid()
-        assert repr(Location('/some/path::archive{pid}')) == \
-            f"Location(proto='file', user=None, host=None, port=None, path='/some/path', archive='archive{test_pid}')"
-        location_time1 = Location('/some/path::archive{now:%s}')
-        sleep(1.1)
-        location_time2 = Location('/some/path::archive{now:%s}')
-        assert location_time1.archive != location_time2.archive
-
     def test_bad_syntax(self):
         with pytest.raises(ValueError):
             # this is invalid due to the 2nd colon, correct: 'ssh://user@host/path'
             Location('ssh://user@host:/path')
 
-    def test_omit_archive(self):
-        from borg.platform import hostname
-        loc = Location('ssh://user@host:1234/repos/{hostname}::archive')
-        loc_without_archive = loc.omit_archive()
-        assert loc_without_archive.archive is None
-        assert loc_without_archive.raw == "ssh://user@host:1234/repos/{hostname}"
-        assert loc_without_archive.processed == "ssh://user@host:1234/repos/%s" % hostname
-
 
 class FormatTimedeltaTestCase(BaseTestCase):
 

From 3e765522de4dccc820e9305758cbee75c664a916 Mon Sep 17 00:00:00 2001
From: Thomas Waldmann <tw@waldmann-edv.de>
Date: Thu, 16 Jun 2022 14:23:47 +0200
Subject: [PATCH 052/160] help: transfer from other repo

---
 src/borg/archiver.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/borg/archiver.py b/src/borg/archiver.py
index 62636c1a0..415bfc001 100644
--- a/src/borg/archiver.py
+++ b/src/borg/archiver.py
@@ -4177,7 +4177,7 @@ class Archiver:
                                help='do not change repository, just check')
         subparser.add_argument('--other-repo', metavar='SRC_REPOSITORY', dest='other_location',
                                type=location_validator(other=True), default=Location(other=True),
-                               help='source repository')
+                               help='transfer archives from the other repository')
         define_archive_filters_group(subparser)
 
         # borg diff

From 801ce819a317d6432c2c25ea6a7c8c7b63221026 Mon Sep 17 00:00:00 2001
From: Thomas Waldmann <tw@waldmann-edv.de>
Date: Thu, 16 Jun 2022 14:32:40 +0200
Subject: [PATCH 053/160] help: archive name

---
 src/borg/archiver.py | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/borg/archiver.py b/src/borg/archiver.py
index 415bfc001..dd834f592 100644
--- a/src/borg/archiver.py
+++ b/src/borg/archiver.py
@@ -3900,7 +3900,7 @@ class Archiver:
 
         archive_group = subparser.add_argument_group('Archive options')
         archive_group.add_argument('--name', dest='name', metavar='NAME', type=NameSpec, default='{hostname}-{now}',
-                                   help='specify the name for the archive')
+                                   help='specify the archive name')
         archive_group.add_argument('--comment', dest='comment', metavar='COMMENT', type=CommentSpec, default='',
                                    help='add a comment text to the archive')
         archive_group.add_argument('--timestamp', metavar='TIMESTAMP', dest='timestamp',
@@ -5000,10 +5000,10 @@ class Archiver:
         subparser.set_defaults(func=self.do_rename)
         subparser.add_argument('--name', metavar='OLDNAME',
                                type=archivename_validator(),
-                               help='the current archive name')
+                               help='specify the archive name')
         subparser.add_argument('--name2', metavar='NEWNAME',
                                type=archivename_validator(),
-                               help='the new archive name')
+                               help='specify the new archive name')
 
         # borg serve
         serve_epilog = process_epilog("""

From 206245f3cdee48e551e38294a6d1d0dc71308a4b Mon Sep 17 00:00:00 2001
From: Thomas Waldmann <tw@waldmann-edv.de>
Date: Thu, 16 Jun 2022 15:41:37 +0200
Subject: [PATCH 054/160] --repo: add -r short option

---
 src/borg/archiver.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/borg/archiver.py b/src/borg/archiver.py
index dd834f592..487b31a16 100644
--- a/src/borg/archiver.py
+++ b/src/borg/archiver.py
@@ -3207,7 +3207,7 @@ class Archiver:
                                    'compatible file can be generated by suffixing FILE with ".pyprof".')
             add_common_option('--rsh', metavar='RSH', dest='rsh',
                               help="Use this command to connect to the 'borg serve' process (default: 'ssh')")
-            add_common_option('--repo', metavar='REPO', dest='location',
+            add_common_option('-r', '--repo', metavar='REPO', dest='location',
                               type=location_validator(other=False), default=Location(other=False),
                               help="repository to use")
 

From c085c2744ba2c2ba9f8c76242090d6bca81ea944 Mon Sep 17 00:00:00 2001
From: Thomas Waldmann <tw@waldmann-edv.de>
Date: Mon, 20 Jun 2022 15:18:24 +0200
Subject: [PATCH 055/160] borg rename NAME NEWNAME

---
 src/borg/archiver.py           | 6 +++---
 src/borg/testsuite/archiver.py | 6 +++---
 2 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/src/borg/archiver.py b/src/borg/archiver.py
index 487b31a16..a12034e3c 100644
--- a/src/borg/archiver.py
+++ b/src/borg/archiver.py
@@ -1508,7 +1508,7 @@ class Archiver:
     @with_archive
     def do_rename(self, args, repository, manifest, key, cache, archive):
         """Rename an existing archive"""
-        archive.rename(args.name2)
+        archive.rename(args.newname)
         manifest.write()
         repository.commit(compact=False)
         cache.commit()
@@ -4998,10 +4998,10 @@ class Archiver:
                                           formatter_class=argparse.RawDescriptionHelpFormatter,
                                           help='rename archive')
         subparser.set_defaults(func=self.do_rename)
-        subparser.add_argument('--name', metavar='OLDNAME',
+        subparser.add_argument('name', metavar='OLDNAME',
                                type=archivename_validator(),
                                help='specify the archive name')
-        subparser.add_argument('--name2', metavar='NEWNAME',
+        subparser.add_argument('newname', metavar='NEWNAME',
                                type=archivename_validator(),
                                help='specify the new archive name')
 
diff --git a/src/borg/testsuite/archiver.py b/src/borg/testsuite/archiver.py
index a22eebe4a..918e8f089 100644
--- a/src/borg/testsuite/archiver.py
+++ b/src/borg/testsuite/archiver.py
@@ -1508,9 +1508,9 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self.cmd(f'--repo={self.repository_location}', 'create', '--name=test.2', 'input')
         self.cmd(f'--repo={self.repository_location}', 'extract', '--name=test', '--dry-run')
         self.cmd(f'--repo={self.repository_location}', 'extract', '--name=test.2', '--dry-run')
-        self.cmd(f'--repo={self.repository_location}', 'rename', '--name=test', '--name2=test.3')
+        self.cmd(f'--repo={self.repository_location}', 'rename', 'test', 'test.3')
         self.cmd(f'--repo={self.repository_location}', 'extract', '--name=test.2', '--dry-run')
-        self.cmd(f'--repo={self.repository_location}', 'rename', '--name=test.2', '--name2=test.4')
+        self.cmd(f'--repo={self.repository_location}', 'rename', 'test.2', 'test.4')
         self.cmd(f'--repo={self.repository_location}', 'extract', '--name=test.3', '--dry-run')
         self.cmd(f'--repo={self.repository_location}', 'extract', '--name=test.4', '--dry-run')
         # Make sure both archives have been renamed
@@ -1854,7 +1854,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         print(self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey'))
         self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', 'input')
         self.add_unknown_feature(Manifest.Operation.CHECK)
-        self.cmd_raises_unknown_feature([f'--repo={self.repository_location}', 'rename', '--name=test', '--name2=other'])
+        self.cmd_raises_unknown_feature([f'--repo={self.repository_location}', 'rename', 'test', 'other'])
 
     def test_unknown_feature_on_delete(self):
         print(self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey'))

From 3fd5b73e1e89f8b1d1a4f22cd910f2f3e9e81ca2 Mon Sep 17 00:00:00 2001
From: Thomas Waldmann <tw@waldmann-edv.de>
Date: Mon, 20 Jun 2022 15:31:26 +0200
Subject: [PATCH 056/160] borg create NAME ...

---
 src/borg/archiver.py            |  16 +-
 src/borg/testsuite/archiver.py  | 438 ++++++++++++++++----------------
 src/borg/testsuite/benchmark.py |   6 +-
 3 files changed, 230 insertions(+), 230 deletions(-)

diff --git a/src/borg/archiver.py b/src/borg/archiver.py
index a12034e3c..1daf2a91c 100644
--- a/src/borg/archiver.py
+++ b/src/borg/archiver.py
@@ -671,20 +671,20 @@ class Archiver:
             compression = '--compression=none'
             # measure create perf (without files cache to always have it chunking)
             t_start = time.monotonic()
-            rc = self.do_create(self.parse_args([f'--repo={repo}', 'create', '--name=borg-benchmark-crud1',
-                                                 compression, '--files-cache=disabled', path]))
+            rc = self.do_create(self.parse_args([f'--repo={repo}', 'create', compression, '--files-cache=disabled',
+                                                 'borg-benchmark-crud1', path]))
             t_end = time.monotonic()
             dt_create = t_end - t_start
             assert rc == 0
             # now build files cache
-            rc1 = self.do_create(self.parse_args([f'--repo={repo}', 'create', '--name=borg-benchmark-crud2',
-                                                  compression, path]))
+            rc1 = self.do_create(self.parse_args([f'--repo={repo}', 'create', compression,
+                                                  'borg-benchmark-crud2', path]))
             rc2 = self.do_delete(self.parse_args([f'--repo={repo}', 'delete', '--name=borg-benchmark-crud2']))
             assert rc1 == rc2 == 0
             # measure a no-change update (archive1 is still present)
             t_start = time.monotonic()
-            rc1 = self.do_create(self.parse_args([f'--repo={repo}', 'create', '--name=borg-benchmark-crud3',
-                                                  compression, path]))
+            rc1 = self.do_create(self.parse_args([f'--repo={repo}', 'create', compression,
+                                                  'borg-benchmark-crud3', path]))
             t_end = time.monotonic()
             dt_update = t_end - t_start
             rc2 = self.do_delete(self.parse_args([f'--repo={repo}', 'delete', '--name=borg-benchmark-crud3']))
@@ -3899,8 +3899,6 @@ class Archiver:
                                    'regular files. Also follows symlinks pointing to these kinds of files.')
 
         archive_group = subparser.add_argument_group('Archive options')
-        archive_group.add_argument('--name', dest='name', metavar='NAME', type=NameSpec, default='{hostname}-{now}',
-                                   help='specify the archive name')
         archive_group.add_argument('--comment', dest='comment', metavar='COMMENT', type=CommentSpec, default='',
                                    help='add a comment text to the archive')
         archive_group.add_argument('--timestamp', metavar='TIMESTAMP', dest='timestamp',
@@ -3919,6 +3917,8 @@ class Archiver:
                                    help='select compression algorithm, see the output of the '
                                         '"borg help compression" command for details.')
 
+        subparser.add_argument('name', metavar='NAME', type=NameSpec,
+                               help='specify the archive name')
         subparser.add_argument('paths', metavar='PATH', nargs='*', type=str,
                                help='paths to archive')
 
diff --git a/src/borg/testsuite/archiver.py b/src/borg/testsuite/archiver.py
index 918e8f089..48f682f23 100644
--- a/src/borg/testsuite/archiver.py
+++ b/src/borg/testsuite/archiver.py
@@ -149,14 +149,14 @@ def test_return_codes(cmd, tmpdir):
     input.join('test_file').write('content')
     rc, out = cmd('--repo=%s' % str(repo), 'init', '--encryption=none')
     assert rc == EXIT_SUCCESS
-    rc, out = cmd('--repo=%s' % repo, 'create', '--name=archive', str(input))
+    rc, out = cmd('--repo=%s' % repo, 'create', 'archive', str(input))
     assert rc == EXIT_SUCCESS
     with changedir(str(output)):
         rc, out = cmd('--repo=%s' % repo, 'extract', '--name=archive')
         assert rc == EXIT_SUCCESS
     rc, out = cmd('--repo=%s' % repo, 'extract', '--name=archive', 'does/not/match')
     assert rc == EXIT_WARNING  # pattern did not match
-    rc, out = cmd('--repo=%s' % repo, 'create', '--name=archive', str(input))
+    rc, out = cmd('--repo=%s' % repo, 'create', 'archive', str(input))
     assert rc == EXIT_ERROR  # duplicate archive name
 
 
@@ -219,7 +219,7 @@ def test_disk_full(cmd):
                             break
                         raise
                     try:
-                        rc, out = cmd('--repo=%s' % repo, 'create', '--name=test%03d' % i, input)
+                        rc, out = cmd('--repo=%s' % repo, 'create', 'test%03d' % i, input)
                         success = rc == EXIT_SUCCESS
                         if not success:
                             print('create', rc, out)
@@ -299,7 +299,7 @@ class ArchiverTestCaseBase(BaseTestCase):
         return output
 
     def create_src_archive(self, name):
-        self.cmd(f'--repo={self.repository_location}', 'create', f'--name={name}', '--compression=lz4', src_dir)
+        self.cmd(f'--repo={self.repository_location}', 'create', '--compression=lz4', name, src_dir)
 
     def open_archive(self, name):
         repository = Repository(self.repository_path, exclusive=True)
@@ -394,8 +394,8 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         output = self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey', '--show-version', '--show-rc', fork=True)
         self.assert_in('borgbackup version', output)
         self.assert_in('terminating with success status, rc 0', output)
-        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', '--exclude-nodump', 'input')
-        output = self.cmd(f'--repo={self.repository_location}', 'create', '--name=test.2', '--exclude-nodump', '--stats', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'create', '--exclude-nodump', 'test', 'input')
+        output = self.cmd(f'--repo={self.repository_location}', 'create', '--exclude-nodump', '--stats', 'test.2', 'input')
         self.assert_in('Archive name: test.2', output)
         self.assert_in('This archive: ', output)
         with changedir('output'):
@@ -463,7 +463,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self.create_regular_file(hl_a, contents=b'123456')
         os.link(hl_a, hl_b)
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=none')
-        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', 'input', 'input')  # give input twice!
+        self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input', 'input')  # give input twice!
         # test if created archive has 'input' contents twice:
         archive_list = self.cmd(f'--repo={self.repository_location}', 'list', '--name=test', '--json-lines')
         paths = [json.loads(line)['path'] for line in archive_list.split('\n') if line]
@@ -491,7 +491,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
                 pytest.skip('unix sockets disabled or not supported')
             elif err.errno == errno.EACCES:
                 pytest.skip('permission denied to create unix sockets')
-        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
         sock.close()
         with changedir('output'):
             self.cmd(f'--repo={self.repository_location}', 'extract', '--name=test')
@@ -501,7 +501,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
     def test_symlink_extract(self):
         self.create_test_files()
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
-        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
         with changedir('output'):
             self.cmd(f'--repo={self.repository_location}', 'extract', '--name=test')
             assert os.readlink('input/link1') == 'somewhere'
@@ -514,7 +514,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
             os.symlink('target', 'symlink1')
             os.link('symlink1', 'symlink2', follow_symlinks=False)
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
-        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
         with changedir('output'):
             output = self.cmd(f'--repo={self.repository_location}', 'extract', '--name=test')
             print(output)
@@ -548,7 +548,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         have_noatime = has_noatime('input/file1')
         os.utime('input/file1', (atime, mtime))
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
-        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', '--atime', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'create', '--atime', 'test', 'input')
         with changedir('output'):
             self.cmd(f'--repo={self.repository_location}', 'extract', '--name=test')
         sti = os.stat('input/file1')
@@ -568,7 +568,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         os.utime('input/file1', (atime, birthtime))
         os.utime('input/file1', (atime, mtime))
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
-        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
         with changedir('output'):
             self.cmd(f'--repo={self.repository_location}', 'extract', '--name=test')
         sti = os.stat('input/file1')
@@ -584,7 +584,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         os.utime('input/file1', (atime, birthtime))
         os.utime('input/file1', (atime, mtime))
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
-        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', '--nobirthtime', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input', '--nobirthtime')
         with changedir('output'):
             self.cmd(f'--repo={self.repository_location}', 'extract', '--name=test')
         sti = os.stat('input/file1')
@@ -645,7 +645,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
             # we could create a sparse input file, so creating a backup of it and
             # extracting it again (as sparse) should also work:
             self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
-            self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', 'input')
+            self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
             with changedir(self.output_path):
                 self.cmd(f'--repo={self.repository_location}', 'extract', '--name=test', '--sparse')
             self.assert_dirs_equal('input', 'output/input')
@@ -664,7 +664,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
             with open(filename, 'wb'):
                 pass
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
-        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
         for filename in filenames:
             with changedir('output'):
                 self.cmd(f'--repo={self.repository_location}', 'extract', '--name=test', os.path.join('input', filename))
@@ -675,70 +675,70 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         os.environ['BORG_PASSPHRASE'] = 'passphrase'
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
         repository_id = self._extract_repository_id(self.repository_path)
-        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
         shutil.rmtree(self.repository_path)
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=none')
         self._set_repository_id(self.repository_path, repository_id)
         self.assert_equal(repository_id, self._extract_repository_id(self.repository_path))
         if self.FORK_DEFAULT:
-            self.cmd(f'--repo={self.repository_location}', 'create', '--name=test.2', 'input', exit_code=EXIT_ERROR)
+            self.cmd(f'--repo={self.repository_location}', 'create', 'test.2', 'input', exit_code=EXIT_ERROR)
         else:
             with pytest.raises(Cache.EncryptionMethodMismatch):
-                self.cmd(f'--repo={self.repository_location}', 'create', '--name=test.2', 'input')
+                self.cmd(f'--repo={self.repository_location}', 'create', 'test.2', 'input')
 
     def test_repository_swap_detection2(self):
         self.create_test_files()
         self.cmd(f'--repo={self.repository_location}_unencrypted', 'init', '--encryption=none')
         os.environ['BORG_PASSPHRASE'] = 'passphrase'
         self.cmd(f'--repo={self.repository_location}_encrypted', 'init', '--encryption=repokey')
-        self.cmd(f'--repo={self.repository_location}_encrypted', 'create', '--name=test', 'input')
+        self.cmd(f'--repo={self.repository_location}_encrypted', 'create', 'test', 'input')
         shutil.rmtree(self.repository_path + '_encrypted')
         os.rename(self.repository_path + '_unencrypted', self.repository_path + '_encrypted')
         if self.FORK_DEFAULT:
-            self.cmd(f'--repo={self.repository_location}_encrypted', 'create', '--name=test.2', 'input', exit_code=EXIT_ERROR)
+            self.cmd(f'--repo={self.repository_location}_encrypted', 'create', 'test.2', 'input', exit_code=EXIT_ERROR)
         else:
             with pytest.raises(Cache.RepositoryAccessAborted):
-                self.cmd(f'--repo={self.repository_location}_encrypted', 'create', '--name=test.2', 'input')
+                self.cmd(f'--repo={self.repository_location}_encrypted', 'create', 'test.2', 'input')
 
     def test_repository_swap_detection_no_cache(self):
         self.create_test_files()
         os.environ['BORG_PASSPHRASE'] = 'passphrase'
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
         repository_id = self._extract_repository_id(self.repository_path)
-        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
         shutil.rmtree(self.repository_path)
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=none')
         self._set_repository_id(self.repository_path, repository_id)
         self.assert_equal(repository_id, self._extract_repository_id(self.repository_path))
         self.cmd(f'--repo={self.repository_location}', 'delete', '--cache-only')
         if self.FORK_DEFAULT:
-            self.cmd(f'--repo={self.repository_location}', 'create', '--name=test.2', 'input', exit_code=EXIT_ERROR)
+            self.cmd(f'--repo={self.repository_location}', 'create', 'test.2', 'input', exit_code=EXIT_ERROR)
         else:
             with pytest.raises(Cache.EncryptionMethodMismatch):
-                self.cmd(f'--repo={self.repository_location}', 'create', '--name=test.2', 'input')
+                self.cmd(f'--repo={self.repository_location}', 'create', 'test.2', 'input')
 
     def test_repository_swap_detection2_no_cache(self):
         self.create_test_files()
         self.cmd(f'--repo={self.repository_location}_unencrypted', 'init', '--encryption=none')
         os.environ['BORG_PASSPHRASE'] = 'passphrase'
         self.cmd(f'--repo={self.repository_location}_encrypted', 'init', '--encryption=repokey')
-        self.cmd(f'--repo={self.repository_location}_encrypted', 'create', '--name=test', 'input')
+        self.cmd(f'--repo={self.repository_location}_encrypted', 'create', 'test', 'input')
         self.cmd(f'--repo={self.repository_location}_unencrypted', 'delete', '--cache-only')
         self.cmd(f'--repo={self.repository_location}_encrypted', 'delete', '--cache-only')
         shutil.rmtree(self.repository_path + '_encrypted')
         os.rename(self.repository_path + '_unencrypted', self.repository_path + '_encrypted')
         if self.FORK_DEFAULT:
-            self.cmd(f'--repo={self.repository_location}_encrypted', 'create', '--name=test.2', 'input', exit_code=EXIT_ERROR)
+            self.cmd(f'--repo={self.repository_location}_encrypted', 'create', 'test.2', 'input', exit_code=EXIT_ERROR)
         else:
             with pytest.raises(Cache.RepositoryAccessAborted):
-                self.cmd(f'--repo={self.repository_location}_encrypted', 'create', '--name=test.2', 'input')
+                self.cmd(f'--repo={self.repository_location}_encrypted', 'create', 'test.2', 'input')
 
     def test_repository_swap_detection_repokey_blank_passphrase(self):
         # Check that a repokey repo with a blank passphrase is considered like a plaintext repo.
         self.create_test_files()
         # User initializes her repository with her passphrase
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
-        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
         # Attacker replaces it with her own repository, which is encrypted but has no passphrase set
         shutil.rmtree(self.repository_path)
         with environment_variable(BORG_PASSPHRASE=''):
@@ -751,10 +751,10 @@ class ArchiverTestCase(ArchiverTestCaseBase):
             # is set, while it isn't. Previously this raised no warning,
             # since the repository is, technically, encrypted.
             if self.FORK_DEFAULT:
-                self.cmd(f'--repo={self.repository_location}', 'create', '--name=test.2', 'input', exit_code=EXIT_ERROR)
+                self.cmd(f'--repo={self.repository_location}', 'create', 'test.2', 'input', exit_code=EXIT_ERROR)
             else:
                 with pytest.raises(Cache.CacheInitAbortedError):
-                    self.cmd(f'--repo={self.repository_location}', 'create', '--name=test.2', 'input')
+                    self.cmd(f'--repo={self.repository_location}', 'create', 'test.2', 'input')
 
     def test_repository_move(self):
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
@@ -805,7 +805,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
     def test_strip_components(self):
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
         self.create_regular_file('dir/file')
-        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
         with changedir('output'):
             self.cmd(f'--repo={self.repository_location}', 'extract', '--name=test', '--strip-components', '3')
             assert not os.path.exists('file')
@@ -833,7 +833,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
                 os.path.join(self.input_path, 'dir1/aaaa'))
 
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
-        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
 
     @requires_hardlinks
     @unittest.skipUnless(llfuse, 'llfuse not installed')
@@ -910,7 +910,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self.create_regular_file(hl_a, contents=b'123456')
         os.link(hl_a, hl_b)
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=none')
-        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', 'input', 'input')  # give input twice!
+        self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input', 'input')  # give input twice!
         # now test extraction
         with changedir('output'):
             self.cmd(f'--repo={self.repository_location}', 'extract', '--name=test')
@@ -927,7 +927,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self.create_regular_file('file2', size=1024 * 80)
         self.create_regular_file('file3', size=1024 * 80)
         self.create_regular_file('file4', size=1024 * 80)
-        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', '--exclude=input/file4', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'create', '--exclude=input/file4', 'test', 'input')
         with changedir('output'):
             self.cmd(f'--repo={self.repository_location}', 'extract', '--name=test', 'input/file1', )
         self.assert_equal(sorted(os.listdir('output/input')), ['file1'])
@@ -947,7 +947,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self.create_regular_file('file333', size=1024 * 80)
 
         # Create with regular expression exclusion for file4
-        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', '--exclude=re:input/file4$', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'create', '--exclude=re:input/file4$', 'test', 'input')
         with changedir('output'):
             self.cmd(f'--repo={self.repository_location}', 'extract', '--name=test')
         self.assert_equal(sorted(os.listdir('output/input')), ['file1', 'file2', 'file3', 'file333'])
@@ -985,7 +985,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
             fd.write(b're:input/file4$\n')
             fd.write(b'fm:*aa:*thing\n')
 
-        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', '--exclude-from=' + self.exclude_file_path, 'input')
+        self.cmd(f'--repo={self.repository_location}', 'create', '--exclude-from=' + self.exclude_file_path, 'test', 'input')
         with changedir('output'):
             self.cmd(f'--repo={self.repository_location}', 'extract', '--name=test')
         self.assert_equal(sorted(os.listdir('output/input')), ['file1', 'file2', 'file3', 'file333'])
@@ -1019,7 +1019,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self.create_regular_file("file4", size=1024 * 80)
         self.create_regular_file("file333", size=1024 * 80)
 
-        self.cmd(f'--repo={self.repository_location}', "create", "--name=test", "input")
+        self.cmd(f'--repo={self.repository_location}', 'create', "test", "input")
 
         # Extract everything with regular expression
         with changedir("output"):
@@ -1048,7 +1048,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
         self.create_regular_file('file', size=1024 * 80)
 
-        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
 
         with changedir('output'):
             output = self.cmd(f'--repo={self.repository_location}', 'extract', '--name=test')
@@ -1072,7 +1072,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
     def test_extract_progress(self):
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
         self.create_regular_file('file', size=1024 * 80)
-        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
 
         with changedir('output'):
             output = self.cmd(f'--repo={self.repository_location}', 'extract', '--name=test', '--progress')
@@ -1095,7 +1095,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
     def test_create_stdin(self):
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
         input_data = b'\x00foo\n\nbar\n   \n'
-        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', '-', input=input_data)
+        self.cmd(f'--repo={self.repository_location}', 'create', 'test', '-', input=input_data)
         item = json.loads(self.cmd(f'--repo={self.repository_location}', 'list', '--name=test', '--json-lines'))
         assert item['uid'] == 0
         assert item['gid'] == 0
@@ -1108,8 +1108,8 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
         input_data = 'some test content'
         name = 'a/b/c'
-        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', '--stdin-name', name, '--content-from-command',
-                 '--', 'echo', input_data)
+        self.cmd(f'--repo={self.repository_location}', 'create', '--stdin-name', name, '--content-from-command',
+                 'test', '--', 'echo', input_data)
         item = json.loads(self.cmd(f'--repo={self.repository_location}', 'list', '--name=test', '--json-lines'))
         assert item['uid'] == 0
         assert item['gid'] == 0
@@ -1120,7 +1120,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
 
     def test_create_content_from_command_with_failed_command(self):
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
-        output = self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', '--content-from-command',
+        output = self.cmd(f'--repo={self.repository_location}', 'create', '--content-from-command', 'test',
                           '--', 'sh', '-c', 'exit 73;', exit_code=2)
         assert output.endswith("Command 'sh' exited with status 73\n")
         archive_list = json.loads(self.cmd(f'--repo={self.repository_location}', 'list', '--json'))
@@ -1128,7 +1128,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
 
     def test_create_content_from_command_missing_command(self):
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
-        output = self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', '--content-from-command', exit_code=2)
+        output = self.cmd(f'--repo={self.repository_location}', 'create', 'test', '--content-from-command', exit_code=2)
         assert output.endswith('No command given.\n')
 
     def test_create_paths_from_stdin(self):
@@ -1139,7 +1139,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self.create_regular_file("file4", size=1024 * 80)
 
         input_data = b'input/file1\0input/dir1\0input/file4'
-        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test',
+        self.cmd(f'--repo={self.repository_location}', 'create', 'test',
                  '--paths-from-stdin', '--paths-delimiter', '\\0', input=input_data)
         archive_list = self.cmd(f'--repo={self.repository_location}', 'list', '--name=test', '--json-lines')
         paths = [json.loads(line)['path'] for line in archive_list.split('\n') if line]
@@ -1153,7 +1153,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self.create_regular_file("file4", size=1024 * 80)
 
         input_data = 'input/file1\ninput/file2\ninput/file3'
-        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', '--paths-from-command',
+        self.cmd(f'--repo={self.repository_location}', 'create', '--paths-from-command', 'test',
                  '--', 'echo', input_data)
         archive_list = self.cmd(f'--repo={self.repository_location}', 'list', '--name=test', '--json-lines')
         paths = [json.loads(line)['path'] for line in archive_list.split('\n') if line]
@@ -1161,7 +1161,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
 
     def test_create_paths_from_command_with_failed_command(self):
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
-        output = self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', '--paths-from-command',
+        output = self.cmd(f'--repo={self.repository_location}', 'create', '--paths-from-command', 'test',
                           '--', 'sh', '-c', 'exit 73;', exit_code=2)
         assert output.endswith("Command 'sh' exited with status 73\n")
         archive_list = json.loads(self.cmd(f'--repo={self.repository_location}', 'list', '--json'))
@@ -1169,20 +1169,20 @@ class ArchiverTestCase(ArchiverTestCaseBase):
 
     def test_create_paths_from_command_missing_command(self):
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
-        output = self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', '--paths-from-command', exit_code=2)
+        output = self.cmd(f'--repo={self.repository_location}', 'create', 'test', '--paths-from-command', exit_code=2)
         assert output.endswith('No command given.\n')
 
     def test_create_without_root(self):
         """test create without a root"""
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
-        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', exit_code=2)
+        self.cmd(f'--repo={self.repository_location}', 'create', 'test', exit_code=2)
 
     def test_create_pattern_root(self):
         """test create with only a root pattern"""
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
         self.create_regular_file('file1', size=1024 * 80)
         self.create_regular_file('file2', size=1024 * 80)
-        output = self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', '-v', '--list', '--pattern=R input')
+        output = self.cmd(f'--repo={self.repository_location}', 'create', 'test', '-v', '--list', '--pattern=R input')
         self.assert_in("A input/file1", output)
         self.assert_in("A input/file2", output)
 
@@ -1192,9 +1192,9 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self.create_regular_file('file1', size=1024 * 80)
         self.create_regular_file('file2', size=1024 * 80)
         self.create_regular_file('file_important', size=1024 * 80)
-        output = self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', '-v', '--list',
+        output = self.cmd(f'--repo={self.repository_location}', 'create', '-v', '--list',
                           '--pattern=+input/file_important', '--pattern=-input/file*',
-                          'input')
+                          'test', 'input')
         self.assert_in("A input/file_important", output)
         self.assert_in('x input/file1', output)
         self.assert_in('x input/file2', output)
@@ -1206,9 +1206,9 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self.create_regular_file('file2', size=1024 * 80)
         self.create_regular_file('otherfile', size=1024 * 80)
         self.create_regular_file('file_important', size=1024 * 80)
-        output = self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', '-v', '--list',
+        output = self.cmd(f'--repo={self.repository_location}', 'create', '-v', '--list',
                           '--pattern=-input/otherfile', '--patterns-from=' + self.patterns_file_path,
-                          'input')
+                          'test', 'input')
         self.assert_in("A input/file_important", output)
         self.assert_in('x input/file1', output)
         self.assert_in('x input/file2', output)
@@ -1224,9 +1224,9 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self.create_regular_file('x/a/foo_a', size=1024 * 80)
         self.create_regular_file('x/b/foo_b', size=1024 * 80)
         self.create_regular_file('y/foo_y', size=1024 * 80)
-        output = self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', '-v', '--list',
+        output = self.cmd(f'--repo={self.repository_location}', 'create', '-v', '--list',
                           '--patterns-from=' + self.patterns_file_path2,
-                          'input')
+                          'test', 'input')
         self.assert_in('x input/x/a/foo_a', output)
         self.assert_in("A input/x/b/foo_b", output)
         self.assert_in('A input/y/foo_y', output)
@@ -1241,9 +1241,9 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self.create_regular_file('x/a/foo_a', size=1024 * 80)
         self.create_regular_file('x/b/foo_b', size=1024 * 80)
         self.create_regular_file('y/foo_y', size=1024 * 80)
-        output = self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', '-v', '--list',
+        output = self.cmd(f'--repo={self.repository_location}', 'create', '-v', '--list',
                           '--patterns-from=' + self.patterns_file_path2,
-                          'input')
+                          'test', 'input')
         self.assert_not_in('input/x/a/foo_a', output)
         self.assert_not_in('input/x/a', output)
         self.assert_in('A input/y/foo_y', output)
@@ -1259,8 +1259,8 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self.create_regular_file('x/a/foo_a', size=1024 * 80)
         self.create_regular_file('x/b/foo_b', size=1024 * 80)
         with changedir('input'):
-            self.cmd(f'--repo={self.repository_location}', 'create', '--name=test',
-                     '--patterns-from=' + self.patterns_file_path2, '.')
+            self.cmd(f'--repo={self.repository_location}', 'create', '--patterns-from=' + self.patterns_file_path2,
+                     'test', '.')
 
         # list the archive and verify that the "intermediate" folders appear before
         # their contents
@@ -1277,15 +1277,15 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self.create_test_files()
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
         self.cmd(f'--repo={self.repository_location}', 'delete', '--cache-only')
-        create_json = json.loads(self.cmd(f'--repo={self.repository_location}', 'create', '--name=test',
-                                          '--no-cache-sync', 'input',
-                                          '--json', '--error'))  # ignore experimental warning
+        create_json = json.loads(self.cmd(f'--repo={self.repository_location}', 'create',
+                                          '--no-cache-sync', '--json', '--error',
+                                          'test', 'input'))  # ignore experimental warning
         info_json = json.loads(self.cmd(f'--repo={self.repository_location}', 'info', '--name=test', '--json'))
         create_stats = create_json['cache']['stats']
         info_stats = info_json['cache']['stats']
         assert create_stats == info_stats
         self.cmd(f'--repo={self.repository_location}', 'delete', '--cache-only')
-        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test2', '--no-cache-sync', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'create', '--no-cache-sync', 'test2', 'input')
         self.cmd(f'--repo={self.repository_location}', 'info')
         self.cmd(f'--repo={self.repository_location}', 'check')
 
@@ -1294,7 +1294,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self.create_regular_file('file1', size=1024 * 80)
         self.create_regular_file('file2', size=1024 * 80)
         self.create_regular_file('file_important', size=1024 * 80)
-        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
         with changedir('output'):
             self.cmd(f'--repo={self.repository_location}', 'extract', '--name=test',
                      '--pattern=+input/file_important', '--pattern=-input/file*')
@@ -1308,12 +1308,12 @@ class ArchiverTestCase(ArchiverTestCaseBase):
 
     def test_exclude_caches(self):
         self._create_test_caches()
-        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', '--exclude-caches', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input', '--exclude-caches')
         self._assert_test_caches()
 
     def test_recreate_exclude_caches(self):
         self._create_test_caches()
-        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
         self.cmd(f'--repo={self.repository_location}', 'recreate', '--name=test', '--exclude-caches')
         self._assert_test_caches()
 
@@ -1331,13 +1331,13 @@ class ArchiverTestCase(ArchiverTestCaseBase):
 
     def test_exclude_tagged(self):
         self._create_test_tagged()
-        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', '--exclude-if-present', '.NOBACKUP',
-                 '--exclude-if-present', '00-NOBACKUP', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input',
+                 '--exclude-if-present', '.NOBACKUP', '--exclude-if-present', '00-NOBACKUP')
         self._assert_test_tagged()
 
     def test_recreate_exclude_tagged(self):
         self._create_test_tagged()
-        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
         self.cmd(f'--repo={self.repository_location}', 'recreate', '--name=test', '--exclude-if-present', '.NOBACKUP',
                  '--exclude-if-present', '00-NOBACKUP')
         self._assert_test_tagged()
@@ -1370,13 +1370,13 @@ class ArchiverTestCase(ArchiverTestCaseBase):
 
     def test_exclude_keep_tagged(self):
         self._create_test_keep_tagged()
-        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', '--exclude-if-present', '.NOBACKUP1',
-                 '--exclude-if-present', '.NOBACKUP2', '--exclude-caches', '--keep-exclude-tags', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input', '--exclude-if-present', '.NOBACKUP1',
+                 '--exclude-if-present', '.NOBACKUP2', '--exclude-caches', '--keep-exclude-tags')
         self._assert_test_keep_tagged()
 
     def test_recreate_exclude_keep_tagged(self):
         self._create_test_keep_tagged()
-        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
         self.cmd(f'--repo={self.repository_location}', 'recreate', '--name=test', '--exclude-if-present', '.NOBACKUP1',
                  '--exclude-if-present', '.NOBACKUP2', '--exclude-caches', '--keep-exclude-tags')
         self._assert_test_keep_tagged()
@@ -1388,7 +1388,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         os.mkdir(os.path.join(self.input_path, 'subdir'))  # to make sure the tag is encountered *after* file1
         os.link(os.path.join(self.input_path, 'file1'),
                 os.path.join(self.input_path, 'subdir', CACHE_TAG_NAME))  # correct tag name, hardlink to file1
-        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
         # in the "test" archive, we now have, in this order:
         # - a regular file item for "file1"
         # - a hardlink item for "CACHEDIR.TAG" referring back to file1 for its contents
@@ -1410,7 +1410,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self.create_regular_file('file')
         xattr.setxattr(b'input/file', b'security.capability', capabilities)
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
-        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
         with changedir('output'):
             with patch.object(os, 'fchown', patched_fchown):
                 self.cmd(f'--repo={self.repository_location}', 'extract', '--name=test')
@@ -1431,7 +1431,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self.create_regular_file('file')
         xattr.setxattr(b'input/file', b'user.attribute', b'value')
         self.cmd(f'--repo={self.repository_location}', 'init', '-e' 'none')
-        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
         with changedir('output'):
             input_abspath = os.path.abspath('input/file')
             with patch.object(xattr, 'setxattr', patched_setxattr_E2BIG):
@@ -1451,7 +1451,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
         self.create_regular_file('dir1/dir2/file', size=1024 * 80)
         with changedir('input/dir1/dir2'):
-            self.cmd(f'--repo={self.repository_location}', 'create', '--name=test',
+            self.cmd(f'--repo={self.repository_location}', 'create', 'test',
                      '../../../input/dir1/../dir1/dir2/..')
         output = self.cmd(f'--repo={self.repository_location}', 'list', '--name=test')
         self.assert_not_in('..', output)
@@ -1462,16 +1462,16 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self.create_regular_file('file1', size=1024 * 80)
         self.create_regular_file('file2', size=1024 * 80)
         with changedir('input'):
-            self.cmd(f'--repo={self.repository_location}', 'create', '--name=test1', '--exclude=file1', '.')
+            self.cmd(f'--repo={self.repository_location}', 'create', 'test1', '.', '--exclude=file1')
         with changedir('output'):
             self.cmd(f'--repo={self.repository_location}', 'extract', '--name=test1')
         self.assert_equal(sorted(os.listdir('output')), ['file2'])
         with changedir('input'):
-            self.cmd(f'--repo={self.repository_location}', 'create', '--name=test2', '--exclude=./file1', '.')
+            self.cmd(f'--repo={self.repository_location}', 'create', 'test2', '.', '--exclude=./file1')
         with changedir('output'):
             self.cmd(f'--repo={self.repository_location}', 'extract', '--name=test2')
         self.assert_equal(sorted(os.listdir('output')), ['file2'])
-        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test3', '--exclude=input/./file1', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'create', 'test3', 'input', '--exclude=input/./file1')
         with changedir('output'):
             self.cmd(f'--repo={self.repository_location}', 'extract', '--name=test3')
         self.assert_equal(sorted(os.listdir('output/input')), ['file2'])
@@ -1479,13 +1479,13 @@ class ArchiverTestCase(ArchiverTestCaseBase):
     def test_repeated_files(self):
         self.create_regular_file('file1', size=1024 * 80)
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
-        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', 'input', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input', 'input')
 
     def test_overwrite(self):
         self.create_regular_file('file1', size=1024 * 80)
         self.create_regular_file('dir2/file2', size=1024 * 80)
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
-        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
         # Overwriting regular files and directories should be supported
         os.mkdir('output/input')
         os.mkdir('output/input/file1')
@@ -1504,8 +1504,8 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self.create_regular_file('file1', size=1024 * 80)
         self.create_regular_file('dir2/file2', size=1024 * 80)
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
-        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', 'input')
-        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test.2', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'create', 'test.2', 'input')
         self.cmd(f'--repo={self.repository_location}', 'extract', '--name=test', '--dry-run')
         self.cmd(f'--repo={self.repository_location}', 'extract', '--name=test.2', '--dry-run')
         self.cmd(f'--repo={self.repository_location}', 'rename', 'test', 'test.3')
@@ -1523,7 +1523,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
     def test_info(self):
         self.create_regular_file('file1', size=1024 * 80)
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
-        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
         info_repo = self.cmd(f'--repo={self.repository_location}', 'info')
         assert 'All archives:' in info_repo
         info_archive = self.cmd(f'--repo={self.repository_location}', 'info', '--name=test')
@@ -1534,7 +1534,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
     def test_info_json(self):
         self.create_regular_file('file1', size=1024 * 80)
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
-        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
         info_repo = json.loads(self.cmd(f'--repo={self.repository_location}', 'info', '--json'))
         repository = info_repo['repository']
         assert len(repository['id']) == 64
@@ -1572,10 +1572,10 @@ class ArchiverTestCase(ArchiverTestCaseBase):
     def test_comment(self):
         self.create_regular_file('file1', size=1024 * 80)
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
-        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test1', 'input')
-        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test2', '--comment', 'this is the comment', 'input')
-        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test3', '--comment', '"deleted" comment', 'input')
-        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test4', '--comment', 'preserved comment', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'create', 'test1', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'create', 'test2', 'input', '--comment', 'this is the comment')
+        self.cmd(f'--repo={self.repository_location}', 'create', 'test3', 'input', '--comment', '"deleted" comment')
+        self.cmd(f'--repo={self.repository_location}', 'create', 'test4', 'input', '--comment', 'preserved comment')
         assert 'Comment: \n' in self.cmd(f'--repo={self.repository_location}', 'info', '--name=test1')
         assert 'Comment: this is the comment' in self.cmd(f'--repo={self.repository_location}', 'info', '--name=test2')
 
@@ -1592,11 +1592,11 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self.create_regular_file('file1', size=1024 * 80)
         self.create_regular_file('dir2/file2', size=1024 * 80)
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
-        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', 'input')
-        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test.2', 'input')
-        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test.3', 'input')
-        self.cmd(f'--repo={self.repository_location}', 'create', '--name=another_test.1', 'input')
-        self.cmd(f'--repo={self.repository_location}', 'create', '--name=another_test.2', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'create', 'test.2', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'create', 'test.3', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'create', 'another_test.1', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'create', 'another_test.2', 'input')
         self.cmd(f'--repo={self.repository_location}', 'extract', '--name=test', '--dry-run')
         self.cmd(f'--repo={self.repository_location}', 'extract', '--name=test.2', '--dry-run')
         self.cmd(f'--repo={self.repository_location}', 'delete', '--prefix', 'another_')
@@ -1612,9 +1612,9 @@ class ArchiverTestCase(ArchiverTestCaseBase):
     def test_delete_multiple(self):
         self.create_regular_file('file1', size=1024 * 80)
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
-        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test1', 'input')
-        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test2', 'input')
-        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test3', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'create', 'test1', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'create', 'test2', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'create', 'test3', 'input')
         self.cmd(f'--repo={self.repository_location}', 'delete', '--name=test1', 'test2')
         self.cmd(f'--repo={self.repository_location}', 'extract', '--name=test3', '--dry-run')
         self.cmd(f'--repo={self.repository_location}', 'delete', '--name=test3')
@@ -1624,8 +1624,8 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self.create_regular_file('file1', size=1024 * 80)
         self.create_regular_file('dir2/file2', size=1024 * 80)
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
-        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', 'input')
-        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test.2', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'create', 'test.2', 'input')
         os.environ['BORG_DELETE_I_KNOW_WHAT_I_AM_DOING'] = 'no'
         self.cmd(f'--repo={self.repository_location}', 'delete', exit_code=2)
         assert os.path.exists(self.repository_path)
@@ -1797,13 +1797,13 @@ class ArchiverTestCase(ArchiverTestCaseBase):
     def test_umask(self):
         self.create_regular_file('file1', size=1024 * 80)
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
-        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
         mode = os.stat(self.repository_path).st_mode
         self.assertEqual(stat.S_IMODE(mode), 0o700)
 
     def test_create_dry_run(self):
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
-        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', '--dry-run', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'create', '--dry-run', 'test', 'input')
         # Make sure no archive has been created
         with Repository(self.repository_path) as repository:
             manifest, key = Manifest.load(repository, Manifest.NO_OPERATION_CHECK)
@@ -1827,13 +1827,13 @@ class ArchiverTestCase(ArchiverTestCaseBase):
     def test_unknown_feature_on_create(self):
         print(self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey'))
         self.add_unknown_feature(Manifest.Operation.WRITE)
-        self.cmd_raises_unknown_feature([f'--repo={self.repository_location}', 'create', '--name=test', 'input'])
+        self.cmd_raises_unknown_feature([f'--repo={self.repository_location}', 'create', 'test', 'input'])
 
     def test_unknown_feature_on_cache_sync(self):
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
         self.cmd(f'--repo={self.repository_location}', 'delete', '--cache-only')
         self.add_unknown_feature(Manifest.Operation.READ)
-        self.cmd_raises_unknown_feature([f'--repo={self.repository_location}', 'create', '--name=test', 'input'])
+        self.cmd_raises_unknown_feature([f'--repo={self.repository_location}', 'create', 'test', 'input'])
 
     def test_unknown_feature_on_change_passphrase(self):
         print(self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey'))
@@ -1842,7 +1842,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
 
     def test_unknown_feature_on_read(self):
         print(self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey'))
-        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
         self.add_unknown_feature(Manifest.Operation.READ)
         with changedir('output'):
             self.cmd_raises_unknown_feature([f'--repo={self.repository_location}', 'extract', '--name=test'])
@@ -1852,13 +1852,13 @@ class ArchiverTestCase(ArchiverTestCaseBase):
 
     def test_unknown_feature_on_rename(self):
         print(self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey'))
-        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
         self.add_unknown_feature(Manifest.Operation.CHECK)
         self.cmd_raises_unknown_feature([f'--repo={self.repository_location}', 'rename', 'test', 'other'])
 
     def test_unknown_feature_on_delete(self):
         print(self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey'))
-        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
         self.add_unknown_feature(Manifest.Operation.DELETE)
         # delete of an archive raises
         self.cmd_raises_unknown_feature([f'--repo={self.repository_location}', 'delete', '--name=test'])
@@ -1869,7 +1869,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
     @unittest.skipUnless(llfuse, 'llfuse not installed')
     def test_unknown_feature_on_mount(self):
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
-        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
         self.add_unknown_feature(Manifest.Operation.READ)
         mountpoint = os.path.join(self.tmpdir, 'mountpoint')
         os.mkdir(mountpoint)
@@ -1895,7 +1895,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
                 cache.commit()
 
         if self.FORK_DEFAULT:
-            self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', 'input')
+            self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
         else:
             called = False
             wipe_cache_safe = LocalCache.wipe_cache
@@ -1906,7 +1906,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
                 wipe_cache_safe(*args)
 
             with patch.object(LocalCache, 'wipe_cache', wipe_wrapper):
-                self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', 'input')
+                self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
 
             assert called
 
@@ -1920,13 +1920,13 @@ class ArchiverTestCase(ArchiverTestCaseBase):
     def test_progress_on(self):
         self.create_regular_file('file1', size=1024 * 80)
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
-        output = self.cmd(f'--repo={self.repository_location}', 'create', '--name=test4', '--progress', 'input')
+        output = self.cmd(f'--repo={self.repository_location}', 'create', 'test4', 'input', '--progress')
         self.assert_in("\r", output)
 
     def test_progress_off(self):
         self.create_regular_file('file1', size=1024 * 80)
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
-        output = self.cmd(f'--repo={self.repository_location}', 'create', '--name=test5', 'input')
+        output = self.cmd(f'--repo={self.repository_location}', 'create', 'test5', 'input')
         self.assert_not_in("\r", output)
 
     def test_file_status(self):
@@ -1937,11 +1937,11 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         time.sleep(1)  # file2 must have newer timestamps than file1
         self.create_regular_file('file2', size=1024 * 80)
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
-        output = self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', '--list', 'input')
+        output = self.cmd(f'--repo={self.repository_location}', 'create', '--list', 'test', 'input')
         self.assert_in("A input/file1", output)
         self.assert_in("A input/file2", output)
         # should find first file as unmodified
-        output = self.cmd(f'--repo={self.repository_location}', 'create', '--name=test2', '--list', 'input')
+        output = self.cmd(f'--repo={self.repository_location}', 'create', '--list', 'test2', 'input')
         self.assert_in("U input/file1", output)
         # this is expected, although surprising, for why, see:
         # https://borgbackup.readthedocs.org/en/latest/faq.html#i-am-seeing-a-added-status-for-a-unchanged-file
@@ -1953,15 +1953,15 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         time.sleep(1)  # file2 must have newer timestamps than file1
         self.create_regular_file('file2', size=10)
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
-        output = self.cmd(f'--repo={self.repository_location}', 'create', '--name=test1',
-                          '--list', '--files-cache=ctime,size', 'input')
+        output = self.cmd(f'--repo={self.repository_location}', 'create', 'test1', 'input',
+                          '--list', '--files-cache=ctime,size')
         # modify file1, but cheat with the mtime (and atime) and also keep same size:
         st = os.stat('input/file1')
         self.create_regular_file('file1', contents=b'321')
         os.utime('input/file1', ns=(st.st_atime_ns, st.st_mtime_ns))
         # this mode uses ctime for change detection, so it should find file1 as modified
-        output = self.cmd(f'--repo={self.repository_location}', 'create', '--name=test2',
-                          '--list', '--files-cache=ctime,size', 'input')
+        output = self.cmd(f'--repo={self.repository_location}', 'create', 'test2', 'input',
+                          '--list', '--files-cache=ctime,size')
         self.assert_in("M input/file1", output)
 
     def test_file_status_ms_cache_mode(self):
@@ -1970,14 +1970,14 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         time.sleep(1)  # file2 must have newer timestamps than file1
         self.create_regular_file('file2', size=10)
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
-        output = self.cmd(f'--repo={self.repository_location}', 'create', '--name=test1',
-                          '--list', '--files-cache=mtime,size', 'input')
+        output = self.cmd(f'--repo={self.repository_location}', 'create',
+                          '--list', '--files-cache=mtime,size', 'test1', 'input')
         # change mode of file1, no content change:
         st = os.stat('input/file1')
         os.chmod('input/file1', st.st_mode ^ stat.S_IRWXO)  # this triggers a ctime change, but mtime is unchanged
         # this mode uses mtime for change detection, so it should find file1 as unmodified
-        output = self.cmd(f'--repo={self.repository_location}', 'create', '--name=test2',
-                          '--list', '--files-cache=mtime,size', 'input')
+        output = self.cmd(f'--repo={self.repository_location}', 'create',
+                          '--list', '--files-cache=mtime,size', 'test2', 'input')
         self.assert_in("U input/file1", output)
 
     def test_file_status_rc_cache_mode(self):
@@ -1986,11 +1986,11 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         time.sleep(1)  # file2 must have newer timestamps than file1
         self.create_regular_file('file2', size=10)
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
-        output = self.cmd(f'--repo={self.repository_location}', 'create', '--name=test1',
-                          '--list', '--files-cache=rechunk,ctime', 'input')
+        output = self.cmd(f'--repo={self.repository_location}', 'create',
+                          '--list', '--files-cache=rechunk,ctime', 'test1', 'input')
         # no changes here, but this mode rechunks unconditionally
-        output = self.cmd(f'--repo={self.repository_location}', 'create', '--name=test2',
-                          '--list', '--files-cache=rechunk,ctime', 'input')
+        output = self.cmd(f'--repo={self.repository_location}', 'create',
+                          '--list', '--files-cache=rechunk,ctime', 'test2', 'input')
         self.assert_in("A input/file1", output)
 
     def test_file_status_excluded(self):
@@ -2003,14 +2003,14 @@ class ArchiverTestCase(ArchiverTestCaseBase):
             self.create_regular_file('file3', size=1024 * 80)
             platform.set_flags(os.path.join(self.input_path, 'file3'), stat.UF_NODUMP)
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
-        output = self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', '--list', '--exclude-nodump', 'input')
+        output = self.cmd(f'--repo={self.repository_location}', 'create', '--list', '--exclude-nodump', 'test', 'input')
         self.assert_in("A input/file1", output)
         self.assert_in("A input/file2", output)
         if has_lchflags:
             self.assert_in("x input/file3", output)
         # should find second file as excluded
-        output = self.cmd(f'--repo={self.repository_location}', 'create', '--name=test1',
-                          '--list', '--exclude-nodump', 'input', '--exclude', '*/file2')
+        output = self.cmd(f'--repo={self.repository_location}', 'create', 'test1', 'input',
+                          '--list', '--exclude-nodump', '--exclude', '*/file2')
         self.assert_in("U input/file1", output)
         self.assert_in("x input/file2", output)
         if has_lchflags:
@@ -2019,8 +2019,8 @@ class ArchiverTestCase(ArchiverTestCaseBase):
     def test_create_json(self):
         self.create_regular_file('file1', size=1024 * 80)
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
-        create_info = json.loads(self.cmd(f'--repo={self.repository_location}', 'create', '--name=test',
-                                          '--json', 'input'))
+        create_info = json.loads(self.cmd(f'--repo={self.repository_location}', 'create', '--json',
+                                          'test', 'input'))
         # The usual keys
         assert 'encryption' in create_info
         assert 'repository' in create_info
@@ -2040,21 +2040,21 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self.create_regular_file('file2', size=1024 * 80)
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
         # no listing by default
-        output = self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', 'input')
+        output = self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
         self.assert_not_in('file1', output)
         # shouldn't be listed even if unchanged
-        output = self.cmd(f'--repo={self.repository_location}', 'create', '--name=test0', 'input')
+        output = self.cmd(f'--repo={self.repository_location}', 'create', 'test0', 'input')
         self.assert_not_in('file1', output)
         # should list the file as unchanged
-        output = self.cmd(f'--repo={self.repository_location}', 'create', '--name=test1', '--list', '--filter=U', 'input')
+        output = self.cmd(f'--repo={self.repository_location}', 'create', 'test1', 'input', '--list', '--filter=U')
         self.assert_in('file1', output)
         # should *not* list the file as changed
-        output = self.cmd(f'--repo={self.repository_location}', 'create', '--name=test2', '--list', '--filter=AM', 'input')
+        output = self.cmd(f'--repo={self.repository_location}', 'create', 'test2', 'input', '--list', '--filter=AM')
         self.assert_not_in('file1', output)
         # change the file
         self.create_regular_file('file1', size=1024 * 100)
         # should list the file as changed
-        output = self.cmd(f'--repo={self.repository_location}', 'create', '--name=test3', '--list', '--filter=AM', 'input')
+        output = self.cmd(f'--repo={self.repository_location}', 'create', 'test3', 'input', '--list', '--filter=AM')
         self.assert_in('file1', output)
 
     @pytest.mark.skipif(not are_fifos_supported(), reason='FIFOs not supported')
@@ -2079,7 +2079,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         t = Thread(target=fifo_feeder, args=(fifo_fn, data))
         t.start()
         try:
-            self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', '--read-special', 'input/link_fifo')
+            self.cmd(f'--repo={self.repository_location}', 'create', '--read-special', 'test', 'input/link_fifo')
         finally:
             t.join()
         with changedir('output'):
@@ -2092,25 +2092,25 @@ class ArchiverTestCase(ArchiverTestCaseBase):
     def test_create_read_special_broken_symlink(self):
         os.symlink('somewhere does not exist', os.path.join(self.input_path, 'link'))
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
-        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', '--read-special', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'create', '--read-special', 'test', 'input')
         output = self.cmd(f'--repo={self.repository_location}', 'list', '--name=test')
         assert 'input/link -> somewhere does not exist' in output
 
     # def test_cmdline_compatibility(self):
     #    self.create_regular_file('file1', size=1024 * 80)
     #    self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
-    #    self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', 'input')
+    #    self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
     #    output = self.cmd('foo', self.repository_location, '--old')
     #    self.assert_in('"--old" has been deprecated. Use "--new" instead', output)
 
     def test_prune_repository(self):
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
-        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test1', src_dir)
-        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test2', src_dir)
+        self.cmd(f'--repo={self.repository_location}', 'create', 'test1', src_dir)
+        self.cmd(f'--repo={self.repository_location}', 'create', 'test2', src_dir)
         # these are not really a checkpoints, but they look like some:
-        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test3.checkpoint', src_dir)
-        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test3.checkpoint.1', src_dir)
-        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test4.checkpoint', src_dir)
+        self.cmd(f'--repo={self.repository_location}', 'create', 'test3.checkpoint', src_dir)
+        self.cmd(f'--repo={self.repository_location}', 'create', 'test3.checkpoint.1', src_dir)
+        self.cmd(f'--repo={self.repository_location}', 'create', 'test4.checkpoint', src_dir)
         output = self.cmd(f'--repo={self.repository_location}', 'prune', '--list', '--dry-run', '--keep-daily=1')
         assert re.search(r'Would prune:\s+test1', output)
         # must keep the latest non-checkpoint archive:
@@ -2133,7 +2133,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self.assert_not_in('test3.checkpoint.1', output)
         self.assert_in('test4.checkpoint', output)
         # now we supersede the latest checkpoint by a successful backup:
-        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test5', src_dir)
+        self.cmd(f'--repo={self.repository_location}', 'create', 'test5', src_dir)
         self.cmd(f'--repo={self.repository_location}', 'prune', '--keep-daily=2')
         output = self.cmd(f'--repo={self.repository_location}', 'list', '--consider-checkpoints')
         # all checkpoints should be gone now:
@@ -2148,8 +2148,8 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         return dtime.astimezone(dateutil.tz.UTC).strftime("%Y-%m-%dT%H:%M:%S")
 
     def _create_archive_ts(self, name, y, m, d, H=0, M=0, S=0):
-        self.cmd(f'--repo={self.repository_location}', 'create', f'--name={name}',
-                 '--timestamp', self._to_utc_timestamp(y, m, d, H, M, S), src_dir)
+        self.cmd(f'--repo={self.repository_location}', 'create',
+                 '--timestamp', self._to_utc_timestamp(y, m, d, H, M, S), name, src_dir)
 
     # This test must match docs/misc/prune-example.txt
     def test_prune_repository_example(self):
@@ -2238,8 +2238,8 @@ class ArchiverTestCase(ArchiverTestCaseBase):
 
     def test_prune_repository_save_space(self):
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
-        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test1', src_dir)
-        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test2', src_dir)
+        self.cmd(f'--repo={self.repository_location}', 'create', 'test1', src_dir)
+        self.cmd(f'--repo={self.repository_location}', 'create', 'test2', src_dir)
         output = self.cmd(f'--repo={self.repository_location}', 'prune', '--list', '--dry-run', '--keep-daily=1')
         assert re.search(r'Keeping archive \(rule: daily #1\):\s+test2', output)
         assert re.search(r'Would prune:\s+test1', output)
@@ -2253,10 +2253,10 @@ class ArchiverTestCase(ArchiverTestCaseBase):
 
     def test_prune_repository_prefix(self):
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
-        self.cmd(f'--repo={self.repository_location}', 'create', '--name=foo-2015-08-12-10:00', src_dir)
-        self.cmd(f'--repo={self.repository_location}', 'create', '--name=foo-2015-08-12-20:00', src_dir)
-        self.cmd(f'--repo={self.repository_location}', 'create', '--name=bar-2015-08-12-10:00', src_dir)
-        self.cmd(f'--repo={self.repository_location}', 'create', '--name=bar-2015-08-12-20:00', src_dir)
+        self.cmd(f'--repo={self.repository_location}', 'create', 'foo-2015-08-12-10:00', src_dir)
+        self.cmd(f'--repo={self.repository_location}', 'create', 'foo-2015-08-12-20:00', src_dir)
+        self.cmd(f'--repo={self.repository_location}', 'create', 'bar-2015-08-12-10:00', src_dir)
+        self.cmd(f'--repo={self.repository_location}', 'create', 'bar-2015-08-12-20:00', src_dir)
         output = self.cmd(f'--repo={self.repository_location}', 'prune', '--list', '--dry-run', '--keep-daily=1', '--prefix=foo-')
         assert re.search(r'Keeping archive \(rule: daily #1\):\s+foo-2015-08-12-20:00', output)
         assert re.search(r'Would prune:\s+foo-2015-08-12-10:00', output)
@@ -2274,10 +2274,10 @@ class ArchiverTestCase(ArchiverTestCaseBase):
 
     def test_prune_repository_glob(self):
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
-        self.cmd(f'--repo={self.repository_location}', 'create', '--name=2015-08-12-10:00-foo', src_dir)
-        self.cmd(f'--repo={self.repository_location}', 'create', '--name=2015-08-12-20:00-foo', src_dir)
-        self.cmd(f'--repo={self.repository_location}', 'create', '--name=2015-08-12-10:00-bar', src_dir)
-        self.cmd(f'--repo={self.repository_location}', 'create', '--name=2015-08-12-20:00-bar', src_dir)
+        self.cmd(f'--repo={self.repository_location}', 'create', '2015-08-12-10:00-foo', src_dir)
+        self.cmd(f'--repo={self.repository_location}', 'create', '2015-08-12-20:00-foo', src_dir)
+        self.cmd(f'--repo={self.repository_location}', 'create', '2015-08-12-10:00-bar', src_dir)
+        self.cmd(f'--repo={self.repository_location}', 'create', '2015-08-12-20:00-bar', src_dir)
         output = self.cmd(f'--repo={self.repository_location}', 'prune', '--list', '--dry-run', '--keep-daily=1', '--glob-archives=2015-*-foo')
         assert re.search(r'Keeping archive \(rule: daily #1\):\s+2015-08-12-20:00-foo', output)
         assert re.search(r'Would prune:\s+2015-08-12-10:00-foo', output)
@@ -2295,9 +2295,9 @@ class ArchiverTestCase(ArchiverTestCaseBase):
 
     def test_list_prefix(self):
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
-        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test-1', src_dir)
-        self.cmd(f'--repo={self.repository_location}', 'create', '--name=something-else-than-test-1', src_dir)
-        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test-2', src_dir)
+        self.cmd(f'--repo={self.repository_location}', 'create', 'test-1', src_dir)
+        self.cmd(f'--repo={self.repository_location}', 'create', 'something-else-than-test-1', src_dir)
+        self.cmd(f'--repo={self.repository_location}', 'create', 'test-2', src_dir)
         output = self.cmd(f'--repo={self.repository_location}', 'list', '--prefix=test-')
         self.assert_in('test-1', output)
         self.assert_in('test-2', output)
@@ -2305,7 +2305,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
 
     def test_list_format(self):
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
-        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', src_dir)
+        self.cmd(f'--repo={self.repository_location}', 'create', 'test', src_dir)
         output_1 = self.cmd(f'--repo={self.repository_location}', 'list', '--name=test')
         output_2 = self.cmd(f'--repo={self.repository_location}', 'list', '--name=test', '--format', '{mode} {user:6} {group:6} {size:8d} {mtime} {path}{extra}{NEWLINE}')
         output_3 = self.cmd(f'--repo={self.repository_location}', 'list', '--name=test', '--format', '{mtime:%s} {path}{NL}')
@@ -2314,8 +2314,8 @@ class ArchiverTestCase(ArchiverTestCaseBase):
 
     def test_list_repository_format(self):
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
-        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test-1', '--comment', 'comment 1', src_dir)
-        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test-2', '--comment', 'comment 2', src_dir)
+        self.cmd(f'--repo={self.repository_location}', 'create', '--comment', 'comment 1', 'test-1', src_dir)
+        self.cmd(f'--repo={self.repository_location}', 'create', '--comment', 'comment 2', 'test-2', src_dir)
         output_1 = self.cmd(f'--repo={self.repository_location}', 'list')
         output_2 = self.cmd(f'--repo={self.repository_location}', 'list', '--format', '{archive:<36} {time} [{id}]{NL}')
         self.assertEqual(output_1, output_2)
@@ -2331,17 +2331,17 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self.create_regular_file('empty_file', size=0)
         self.create_regular_file('amb', contents=b'a' * 1000000)
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
-        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
         output = self.cmd(f'--repo={self.repository_location}', 'list', '--name=test', '--format', '{sha256} {path}{NL}')
         assert "cdc76e5c9914fb9281a1c7e284d73e67f1809a48a497200e046d39ccc7112cd0 input/amb" in output
         assert "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855 input/empty_file" in output
 
     def test_list_consider_checkpoints(self):
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
-        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test1', src_dir)
+        self.cmd(f'--repo={self.repository_location}', 'create', 'test1', src_dir)
         # these are not really a checkpoints, but they look like some:
-        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test2.checkpoint', src_dir)
-        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test3.checkpoint.1', src_dir)
+        self.cmd(f'--repo={self.repository_location}', 'create', 'test2.checkpoint', src_dir)
+        self.cmd(f'--repo={self.repository_location}', 'create', 'test3.checkpoint.1', src_dir)
         output = self.cmd(f'--repo={self.repository_location}', 'list')
         assert "test1" in output
         assert "test2.checkpoint" not in output
@@ -2358,7 +2358,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
             fd.write(b'abba' * 2000000)
             fd.write(b'baab' * 2000000)
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
-        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
         output = self.cmd(f'--repo={self.repository_location}', 'list', '--name=test', '--format', '{num_chunks} {unique_chunks} {path}{NL}')
         assert "0 0 input/empty_file" in output
         assert "2 2 input/two_chunks" in output
@@ -2366,7 +2366,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
     def test_list_size(self):
         self.create_regular_file('compressible_file', size=10000)
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
-        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', '-C', 'lz4', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'create', '-C', 'lz4', 'test', 'input')
         output = self.cmd(f'--repo={self.repository_location}', 'list', '--name=test', '--format', '{size} {path}{NL}')
         size, path = output.split("\n")[1].split(" ")
         assert int(size) == 10000
@@ -2374,7 +2374,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
     def test_list_json(self):
         self.create_regular_file('file1', size=1024 * 80)
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
-        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
         list_repo = json.loads(self.cmd(f'--repo={self.repository_location}', 'list', '--json'))
         repository = list_repo['repository']
         assert len(repository['id']) == 64
@@ -2407,7 +2407,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
     def test_log_json(self):
         self.create_test_files()
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
-        log = self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', '--log-json', 'input', '--list', '--debug')
+        log = self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input', '--log-json', '--list', '--debug')
         messages = {}  # type -> message, one of each kind
         for line in log.splitlines():
             msg = json.loads(line)
@@ -2425,13 +2425,13 @@ class ArchiverTestCase(ArchiverTestCaseBase):
     def test_debug_profile(self):
         self.create_test_files()
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
-        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', 'input', '--debug-profile=create.prof')
+        self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input', '--debug-profile=create.prof')
         self.cmd('debug', 'convert-profile', 'create.prof', 'create.pyprof')
         stats = pstats.Stats('create.pyprof')
         stats.strip_dirs()
         stats.sort_stats('cumtime')
 
-        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test2', 'input', '--debug-profile=create.pyprof')
+        self.cmd(f'--repo={self.repository_location}', 'create', 'test2', 'input', '--debug-profile=create.pyprof')
         stats = pstats.Stats('create.pyprof')  # Only do this on trusted data!
         stats.strip_dirs()
         stats.sort_stats('cumtime')
@@ -2439,7 +2439,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
     def test_common_options(self):
         self.create_test_files()
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
-        log = self.cmd(f'--repo={self.repository_location}', '--debug', 'create', '--name=test', 'input')
+        log = self.cmd(f'--repo={self.repository_location}', '--debug', 'create', 'test', 'input')
         assert 'security: read previous location' in log
 
     def test_change_passphrase(self):
@@ -2513,8 +2513,8 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
         self.create_test_files()
         have_noatime = has_noatime('input/file1')
-        self.cmd(f'--repo={self.repository_location}', 'create', '--name=archive', '--exclude-nodump', '--atime', 'input')
-        self.cmd(f'--repo={self.repository_location}', 'create', '--name=archive2', '--exclude-nodump', '--atime', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'create', '--exclude-nodump', '--atime', 'archive', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'create', '--exclude-nodump', '--atime', 'archive2', 'input')
         if has_lchflags:
             # remove the file we did not backup, so input and output become equal
             os.remove(os.path.join('input', 'flagfile'))
@@ -2606,9 +2606,9 @@ class ArchiverTestCase(ArchiverTestCaseBase):
             self.create_regular_file('hardlink1', contents=b'123456')
             os.link('input/hardlink1', 'input/hardlink2')
             os.link('input/hardlink1', 'input/hardlink3')
-        self.cmd(f'--repo={self.repository_location}', 'create', '--name=archive1', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'create', 'archive1', 'input')
         self.create_regular_file('test', contents=b'second')
-        self.cmd(f'--repo={self.repository_location}', 'create', '--name=archive2', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'create', 'archive2', 'input')
         mountpoint = os.path.join(self.tmpdir, 'mountpoint')
         # mount the whole repository, archive contents shall show up in versioned view:
         with self.fuse_mount(self.repository_location, mountpoint, '-o', 'versions'):
@@ -2786,9 +2786,9 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         os.environ['BORG_PASSPHRASE'] = 'passphrase'
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=' + method)
         verify_uniqueness()
-        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
         verify_uniqueness()
-        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test.2', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'create', 'test.2', 'input')
         verify_uniqueness()
         self.cmd(f'--repo={self.repository_location}', 'delete', '--name=test.2')
         verify_uniqueness()
@@ -2802,7 +2802,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
     def test_debug_dump_archive_items(self):
         self.create_test_files()
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
-        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
         with changedir('output'):
             output = self.cmd(f'--repo={self.repository_location}', 'debug', 'dump-archive-items', '--name=test')
         output_dir = sorted(os.listdir('output'))
@@ -2812,7 +2812,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
     def test_debug_dump_repo_objs(self):
         self.create_test_files()
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
-        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
         with changedir('output'):
             output = self.cmd(f'--repo={self.repository_location}', 'debug', 'dump-repo-objs')
         output_dir = sorted(os.listdir('output'))
@@ -2899,7 +2899,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
 
     def test_check_cache(self):
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
-        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
         with self.open_repository() as repository:
             manifest, key = Manifest.load(repository, Manifest.NO_OPERATION_CHECK)
             with Cache(repository, key, manifest, sync=False) as cache:
@@ -2918,7 +2918,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self.create_test_files()
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
         self.check_cache()
-        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test0', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'create', 'test0', 'input')
         self.check_cache()
         original_archive = self.cmd(f'--repo={self.repository_location}', 'list')
         self.cmd(f'--repo={self.repository_location}', 'recreate', '--name=test0', 'input/dir2',
@@ -2937,7 +2937,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self.create_test_files()
         self.create_regular_file('dir2/file3', size=1024 * 80)
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
-        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test0', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'create', 'test0', 'input')
         self.cmd(f'--repo={self.repository_location}', 'recreate', '--name=test0', 'input/dir2', '-e', 'input/dir2/file3')
         self.check_cache()
         listing = self.cmd(f'--repo={self.repository_location}', 'list', '--name=test0', '--short')
@@ -2949,7 +2949,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
     def test_recreate_subtree_hardlinks(self):
         # This is essentially the same problem set as in test_extract_hardlinks
         self._extract_hardlinks_setup()
-        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test2', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'create', 'test2', 'input')
         self.cmd(f'--repo={self.repository_location}', 'recreate', '--name=test', 'input/dir1')
         self.check_cache()
         with changedir('output'):
@@ -2967,8 +2967,8 @@ class ArchiverTestCase(ArchiverTestCaseBase):
             fd.write(b'a' * 280)
             fd.write(b'b' * 280)
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
-        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test1', '--chunker-params', '7,9,8,128', 'input')
-        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test2', 'input', '--files-cache=disabled')
+        self.cmd(f'--repo={self.repository_location}', 'create', 'test1', 'input', '--chunker-params', '7,9,8,128')
+        self.cmd(f'--repo={self.repository_location}', 'create', 'test2', 'input', '--files-cache=disabled')
         list = self.cmd(f'--repo={self.repository_location}', 'list', '--name=test1', 'input/large_file',
                         '--format', '{num_chunks} {unique_chunks}')
         num_chunks, unique_chunks = map(int, list.split(' '))
@@ -2984,7 +2984,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
     def test_recreate_recompress(self):
         self.create_regular_file('compressible', size=10000)
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
-        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', 'input', '-C', 'none')
+        self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input', '-C', 'none')
         file_list = self.cmd(f'--repo={self.repository_location}', 'list', '--name=test', 'input/compressible',
                              '--format', '{size} {sha256}')
         size, sha256_before = file_list.split(' ')
@@ -2999,7 +2999,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         local_timezone = datetime.now(timezone(timedelta(0))).astimezone().tzinfo
         self.create_test_files()
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
-        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test0', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'create', 'test0', 'input')
         self.cmd(f'--repo={self.repository_location}', 'recreate', '--name=test0', '--timestamp', "1970-01-02T00:00:00",
                  '--comment', 'test')
         info = self.cmd(f'--repo={self.repository_location}', 'info', '--name=test0').splitlines()
@@ -3011,7 +3011,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
     def test_recreate_dry_run(self):
         self.create_regular_file('compressible', size=10000)
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
-        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
         archives_before = self.cmd(f'--repo={self.repository_location}', 'list', '--name=test')
         self.cmd(f'--repo={self.repository_location}', 'recreate', '-n', '-e', 'input/compressible')
         self.check_cache()
@@ -3021,7 +3021,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
     def test_recreate_skips_nothing_to_do(self):
         self.create_regular_file('file1', size=1024 * 80)
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
-        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
         info_before = self.cmd(f'--repo={self.repository_location}', 'info', '--name=test')
         self.cmd(f'--repo={self.repository_location}', 'recreate', '--chunker-params', 'default')
         self.check_cache()
@@ -3042,7 +3042,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self.create_regular_file('file4', size=0)
         self.create_regular_file('file5', size=0)
 
-        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
 
         output = self.cmd(f'--repo={self.repository_location}', 'recreate', '--name=test', '--list', '--info', '-e', 'input/file2')
         self.check_cache()
@@ -3066,7 +3066,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
 
     def test_bad_filters(self):
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
-        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
         self.cmd(f'--repo={self.repository_location}', 'delete', '--first', '1', '--last', '1', fork=True, exit_code=2)
 
     def test_key_export_keyfile(self):
@@ -3266,7 +3266,7 @@ id: 2 / e29442 3506da 4e1ea7 / 25f62a 5a3d41 - 02
     def test_debug_dump_manifest(self):
         self.create_regular_file('file1', size=1024 * 80)
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
-        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
         dump_file = self.output_path + '/dump'
         output = self.cmd(f'--repo={self.repository_location}', 'debug', 'dump-manifest', dump_file)
         assert output == ""
@@ -3281,7 +3281,7 @@ id: 2 / e29442 3506da 4e1ea7 / 25f62a 5a3d41 - 02
     def test_debug_dump_archive(self):
         self.create_regular_file('file1', size=1024 * 80)
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
-        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
         dump_file = self.output_path + '/dump'
         output = self.cmd(f'--repo={self.repository_location}', 'debug', 'dump-archive', '--name=test', dump_file)
         assert output == ""
@@ -3297,7 +3297,7 @@ id: 2 / e29442 3506da 4e1ea7 / 25f62a 5a3d41 - 02
         output = self.cmd(f'--repo={self.repository_location}', 'debug', 'refcount-obj', '0' * 64).strip()
         assert output == 'object 0000000000000000000000000000000000000000000000000000000000000000 not found [info from chunks cache].'
 
-        create_json = json.loads(self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', '--json', 'input'))
+        create_json = json.loads(self.cmd(f'--repo={self.repository_location}', 'create', '--json', 'test', 'input'))
         archive_id = create_json['archive']['id']
         output = self.cmd(f'--repo={self.repository_location}', 'debug', 'refcount-obj', archive_id).strip()
         assert output == 'object ' + archive_id + ' has 1 referrers [info from chunks cache].'
@@ -3363,7 +3363,7 @@ id: 2 / e29442 3506da 4e1ea7 / 25f62a 5a3d41 - 02
         self.create_test_files()
         os.unlink('input/flagfile')
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
-        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
         self.cmd(f'--repo={self.repository_location}', 'export-tar', '--name=test', 'simple.tar', '--progress', '--tar-format=GNU')
         with changedir('output'):
             # This probably assumes GNU tar. Note -p switch to extract permissions regardless of umask.
@@ -3378,7 +3378,7 @@ id: 2 / e29442 3506da 4e1ea7 / 25f62a 5a3d41 - 02
         self.create_test_files()
         os.unlink('input/flagfile')
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
-        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
         list = self.cmd(f'--repo={self.repository_location}', 'export-tar', '--name=test', 'simple.tar.gz',
                         '--list', '--tar-format=GNU')
         assert 'input/file1\n' in list
@@ -3394,7 +3394,7 @@ id: 2 / e29442 3506da 4e1ea7 / 25f62a 5a3d41 - 02
         self.create_test_files()
         os.unlink('input/flagfile')
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
-        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
         list = self.cmd(f'--repo={self.repository_location}', 'export-tar', '--name=test', 'simple.tar',
                         '--strip-components=1', '--list', '--tar-format=GNU')
         # --list's path are those before processing with --strip-components
@@ -3433,7 +3433,7 @@ id: 2 / e29442 3506da 4e1ea7 / 25f62a 5a3d41 - 02
         self.create_test_files(create_hardlinks=False)  # hardlinks become separate files
         os.unlink('input/flagfile')
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=none')
-        self.cmd(f'--repo={self.repository_location}', 'create', '--name=src', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'create', 'src', 'input')
         self.cmd(f'--repo={self.repository_location}', 'export-tar', '--name=src', 'simple.tar', f'--tar-format={tar_format}')
         self.cmd(f'--repo={self.repository_location}', 'import-tar', '--name=dst', 'simple.tar')
         with changedir(self.output_path):
@@ -3447,7 +3447,7 @@ id: 2 / e29442 3506da 4e1ea7 / 25f62a 5a3d41 - 02
         self.create_test_files(create_hardlinks=False)  # hardlinks become separate files
         os.unlink('input/flagfile')
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=none')
-        self.cmd(f'--repo={self.repository_location}', 'create', '--name=src', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'create', 'src', 'input')
         self.cmd(f'--repo={self.repository_location}', 'export-tar', '--name=src', 'simple.tgz', f'--tar-format={tar_format}')
         self.cmd(f'--repo={self.repository_location}', 'import-tar', '--name=dst', 'simple.tgz')
         with changedir(self.output_path):
@@ -3457,7 +3457,7 @@ id: 2 / e29442 3506da 4e1ea7 / 25f62a 5a3d41 - 02
     def test_roundtrip_pax_borg(self):
         self.create_test_files()
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=none')
-        self.cmd(f'--repo={self.repository_location}', 'create', '--name=src', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'create', 'src', 'input')
         self.cmd(f'--repo={self.repository_location}', 'export-tar', '--name=src', 'simple.tar', '--tar-format=BORG')
         self.cmd(f'--repo={self.repository_location}', 'import-tar', '--name=dst', 'simple.tar')
         with changedir(self.output_path):
@@ -3475,7 +3475,7 @@ id: 2 / e29442 3506da 4e1ea7 / 25f62a 5a3d41 - 02
         self.create_regular_file('file')
         xattr.setxattr(b'input/file', b'user.attribute%p', b'value')
         self.cmd('init', self.repository_location, '-e' 'none')
-        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
         with changedir('output'):
             with patch.object(xattr, 'setxattr', patched_setxattr_EACCES):
                 self.cmd(f'--repo={self.repository_location}', 'extract', '--name=test', exit_code=EXIT_WARNING)
@@ -3491,7 +3491,7 @@ id: 2 / e29442 3506da 4e1ea7 / 25f62a 5a3d41 - 02
         os.makedirs(os.path.join(self.input_path, 'dir%p'))
         xattr.setxattr(b'input/dir%p', b'user.attribute', b'value')
         self.cmd(f'--repo={self.repository_location}', 'init', '-e' 'none')
-        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
         with changedir('output'):
             with patch.object(xattr, 'setxattr', patched_setxattr_EACCES):
                 self.cmd(f'--repo={self.repository_location}', 'extract', '--name=test', exit_code=EXIT_WARNING)
@@ -3510,7 +3510,7 @@ id: 2 / e29442 3506da 4e1ea7 / 25f62a 5a3d41 - 02
         both the client and the server forget the nonce"""
         self.create_regular_file('file1', contents=b'Hello, borg')
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
-        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
         # Oops! We have removed the repo-side memory of the nonce!
         # See https://github.com/borgbackup/borg/issues/5858
         os.remove(os.path.join(self.repository_path, 'nonce'))
@@ -3541,13 +3541,13 @@ id: 2 / e29442 3506da 4e1ea7 / 25f62a 5a3d41 - 02
         """
         self.create_regular_file('file1', contents=b'Hello, borg')
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
-        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
         # Oops! We have removed the repo-side memory of the nonce!
         # See https://github.com/borgbackup/borg/issues/5858
         nonce = os.path.join(self.repository_path, 'nonce')
         os.remove(nonce)
 
-        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test2', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'create', 'test2', 'input')
         assert os.path.exists(nonce)
 
     def test_init_defaults_to_argon2(self):
@@ -3994,7 +3994,7 @@ class RemoteArchiverTestCase(ArchiverTestCase):
         self.create_regular_file('skipped-file1', contents=b"test file contents 3")
         self.create_regular_file('skipped-file2', contents=b"test file contents 4")
         self.create_regular_file('skipped-file3', contents=b"test file contents 5")
-        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
         marker = 'cached responses left in RemoteRepository'
         with changedir('output'):
             res = self.cmd(f'--repo={self.repository_location}', 'extract', '--name=test', "--debug", '--strip-components', '3')
@@ -4035,17 +4035,17 @@ class ArchiverCorruptionTestCase(ArchiverTestCaseBase):
                 self.cmd(f'--repo={self.repository_location}', 'info')
 
     def test_cache_files(self):
-        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
         self.corrupt(os.path.join(self.cache_path, 'files'))
-        out = self.cmd(f'--repo={self.repository_location}', 'create', '--name=test1', 'input')
+        out = self.cmd(f'--repo={self.repository_location}', 'create', 'test1', 'input')
         # borg warns about the corrupt files cache, but then continues without files cache.
         assert 'files cache is corrupted' in out
 
     def test_chunks_archive(self):
-        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test1', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'create', 'test1', 'input')
         # Find ID of test1 so we can corrupt it later :)
         target_id = self.cmd(f'--repo={self.repository_location}', 'list', '--format={id}{LF}').strip()
-        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test2', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'create', 'test2', 'input')
 
         # Force cache sync, creating archive chunks of test1 and test2 in chunks.archive.d
         self.cmd(f'--repo={self.repository_location}', 'delete', '--cache-only')
@@ -4065,7 +4065,7 @@ class ArchiverCorruptionTestCase(ArchiverTestCaseBase):
             config.write(fd)
 
         # Cache sync notices corrupted archive chunks, but automatically recovers.
-        out = self.cmd(f'--repo={self.repository_location}', 'create', '--name=test3', '-v', 'input', exit_code=1)
+        out = self.cmd(f'--repo={self.repository_location}', 'create', '-v', 'test3', 'input', exit_code=1)
         assert 'Reading cached archive chunk index for test1' in out
         assert 'Cached archive chunk index of test1 is corrupted' in out
         assert 'Fetching and building archive index for test1' in out
@@ -4111,7 +4111,7 @@ class DiffArchiverTestCase(ArchiverTestCaseBase):
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
 
         # Create the first snapshot
-        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test0', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'create', 'test0', 'input')
 
         # Setup files for the second snapshot
         self.create_regular_file('file_added', size=2048)
@@ -4142,8 +4142,8 @@ class DiffArchiverTestCase(ArchiverTestCaseBase):
             fd.write(b'appended_data')
 
         # Create the second snapshot
-        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test1a', 'input')
-        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test1b', '--chunker-params', '16,18,17,4095', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'create', 'test1a', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'create', 'test1b', 'input', '--chunker-params', '16,18,17,4095')
 
         def do_asserts(output, can_compare_ids):
             # File contents changed (deleted and replaced with a new file)
@@ -4300,7 +4300,7 @@ class DiffArchiverTestCase(ArchiverTestCaseBase):
         self.create_regular_file('f_file_removed', size=16)
         self.create_regular_file('c_file_changed', size=32)
         self.create_regular_file('e_file_changed', size=64)
-        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test0', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'create', 'test0', 'input')
 
         os.unlink('input/a_file_removed')
         os.unlink('input/f_file_removed')
@@ -4310,7 +4310,7 @@ class DiffArchiverTestCase(ArchiverTestCaseBase):
         self.create_regular_file('e_file_changed', size=1024)
         self.create_regular_file('b_file_added', size=128)
         self.create_regular_file('d_file_added', size=256)
-        self.cmd(f'--repo={self.repository_location}', 'create', '--name=test1', 'input')
+        self.cmd(f'--repo={self.repository_location}', 'create', 'test1', 'input')
 
         output = self.cmd(f'--repo={self.repository_location}', 'diff', '--name=test0', '--name2=test1',
                           '--sort')
diff --git a/src/borg/testsuite/benchmark.py b/src/borg/testsuite/benchmark.py
index 4eb3a3da6..fac828c13 100644
--- a/src/borg/testsuite/benchmark.py
+++ b/src/borg/testsuite/benchmark.py
@@ -57,19 +57,19 @@ def testdata(request, tmpdir_factory):
 @pytest.fixture(params=['none', 'lz4'])
 def repo_archive(request, cmd, repo, testdata):
     archive = 'test'
-    cmd(f'--repo={repo}', 'create', f'--name={archive}', '--compression', request.param, testdata)
+    cmd(f'--repo={repo}', 'create', f'{archive}', '--compression', request.param, testdata)
     return repo, archive
 
 
 def test_create_none(benchmark, cmd, repo, testdata):
     result, out = benchmark.pedantic(cmd, (f'--repo={repo}', 'create', '--compression', 'none',
-                                           '--name', 'test', testdata))
+                                           'test', testdata))
     assert result == 0
 
 
 def test_create_lz4(benchmark, cmd, repo, testdata):
     result, out = benchmark.pedantic(cmd, (f'--repo={repo}', 'create', '--compression', 'lz4',
-                                           '--name', 'test', testdata))
+                                           'test', testdata))
     assert result == 0
 
 

From f8d2024578e199a2c20d4d478839808fc98eefd0 Mon Sep 17 00:00:00 2001
From: Thomas Waldmann <tw@waldmann-edv.de>
Date: Mon, 20 Jun 2022 15:56:03 +0200
Subject: [PATCH 057/160] borg recreate -a ARCHIVE_GLOB ...

---
 src/borg/archiver.py           | 28 +++++++++-------------------
 src/borg/helpers/manifest.py   |  8 +++++---
 src/borg/testsuite/archiver.py | 32 ++++++++++++++++----------------
 3 files changed, 30 insertions(+), 38 deletions(-)

diff --git a/src/borg/archiver.py b/src/borg/archiver.py
index 1daf2a91c..f82b4726b 100644
--- a/src/borg/archiver.py
+++ b/src/borg/archiver.py
@@ -2005,25 +2005,16 @@ class Archiver:
                                      checkpoint_interval=args.checkpoint_interval,
                                      dry_run=args.dry_run, timestamp=args.timestamp)
 
-        if args.name:
-            name = args.name
+        archive_names = tuple(archive.name for archive in manifest.archives.list_considering(args))
+        if args.target is not None and len(archive_names) != 1:
+            self.print_error('--target: Need to specify single archive')
+            return self.exit_code
+        for name in archive_names:
             if recreater.is_temporary_archive(name):
-                self.print_error('Refusing to work on temporary archive of prior recreate: %s', name)
-                return self.exit_code
+                continue
+            print('Processing', name)
             if not recreater.recreate(name, args.comment, args.target):
-                self.print_error('Nothing to do. Archive was not processed.\n'
-                                 'Specify at least one pattern, PATH, --comment, re-compression or re-chunking option.')
-        else:
-            if args.target is not None:
-                self.print_error('--target: Need to specify single archive')
-                return self.exit_code
-            for archive in manifest.archives.list(sort_by=['ts']):
-                name = archive.name
-                if recreater.is_temporary_archive(name):
-                    continue
-                print('Processing', name)
-                if not recreater.recreate(name, args.comment):
-                    logger.info('Skipped archive %s: Nothing to do. Archive was not processed.', name)
+                logger.info('Skipped archive %s: Nothing to do. Archive was not processed.', name)
         if not args.dry_run:
             manifest.write()
             repository.commit(compact=False)
@@ -4946,6 +4937,7 @@ class Archiver:
         define_exclusion_group(subparser, tag_files=True)
 
         archive_group = subparser.add_argument_group('Archive options')
+        define_archive_filters_group(archive_group)
         archive_group.add_argument('--target', dest='target', metavar='TARGET', default=None,
                                    type=archivename_validator(),
                                    help='create a new archive with the name ARCHIVE, do not replace existing archive '
@@ -4981,8 +4973,6 @@ class Archiver:
                                         'HASH_MASK_BITS, HASH_WINDOW_SIZE) or `default` to use the current defaults. '
                                         'default: %s,%d,%d,%d,%d' % CHUNKER_PARAMS)
 
-        subparser.add_argument('--name', dest='name', metavar='NAME', type=NameSpec,
-                               help='specify the archive name')
         subparser.add_argument('paths', metavar='PATH', nargs='*', type=str,
                                help='paths to recreate; patterns are supported')
 
diff --git a/src/borg/helpers/manifest.py b/src/borg/helpers/manifest.py
index 587176b49..786eb27bb 100644
--- a/src/borg/helpers/manifest.py
+++ b/src/borg/helpers/manifest.py
@@ -103,11 +103,13 @@ class Archives(abc.MutableMapping):
         """
         get a list of archives, considering --first/last/prefix/glob-archives/sort/consider-checkpoints cmdline args
         """
-        if args.name:
-            raise Error('The options --first, --last, --prefix, and --glob-archives, and --consider-checkpoints can only be used on repository targets.')
+        name = getattr(args, 'name', None)
+        consider_checkpoints = getattr(args, 'consider_checkpoints', None)
+        if name is not None:
+            raise Error('Giving a specific name is incompatible with options --first, --last, --prefix, and --glob-archives, and --consider-checkpoints.')
         if args.prefix is not None:
             args.glob_archives = args.prefix + '*'
-        return self.list(sort_by=args.sort_by.split(','), consider_checkpoints=args.consider_checkpoints, glob=args.glob_archives, first=args.first, last=args.last)
+        return self.list(sort_by=args.sort_by.split(','), consider_checkpoints=consider_checkpoints, glob=args.glob_archives, first=args.first, last=args.last)
 
     def set_raw_dict(self, d):
         """set the dict we get from the msgpack unpacker"""
diff --git a/src/borg/testsuite/archiver.py b/src/borg/testsuite/archiver.py
index 48f682f23..b9c18ec22 100644
--- a/src/borg/testsuite/archiver.py
+++ b/src/borg/testsuite/archiver.py
@@ -1314,7 +1314,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
     def test_recreate_exclude_caches(self):
         self._create_test_caches()
         self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
-        self.cmd(f'--repo={self.repository_location}', 'recreate', '--name=test', '--exclude-caches')
+        self.cmd(f'--repo={self.repository_location}', 'recreate', '-a', 'test', '--exclude-caches')
         self._assert_test_caches()
 
     def _create_test_tagged(self):
@@ -1338,7 +1338,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
     def test_recreate_exclude_tagged(self):
         self._create_test_tagged()
         self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
-        self.cmd(f'--repo={self.repository_location}', 'recreate', '--name=test', '--exclude-if-present', '.NOBACKUP',
+        self.cmd(f'--repo={self.repository_location}', 'recreate', '-a', 'test', '--exclude-if-present', '.NOBACKUP',
                  '--exclude-if-present', '00-NOBACKUP')
         self._assert_test_tagged()
 
@@ -1377,7 +1377,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
     def test_recreate_exclude_keep_tagged(self):
         self._create_test_keep_tagged()
         self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
-        self.cmd(f'--repo={self.repository_location}', 'recreate', '--name=test', '--exclude-if-present', '.NOBACKUP1',
+        self.cmd(f'--repo={self.repository_location}', 'recreate', '-a', 'test', '--exclude-if-present', '.NOBACKUP1',
                  '--exclude-if-present', '.NOBACKUP2', '--exclude-caches', '--keep-exclude-tags')
         self._assert_test_keep_tagged()
 
@@ -1392,7 +1392,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         # in the "test" archive, we now have, in this order:
         # - a regular file item for "file1"
         # - a hardlink item for "CACHEDIR.TAG" referring back to file1 for its contents
-        self.cmd(f'--repo={self.repository_location}', 'recreate', '--name=test', '--exclude-caches', '--keep-exclude-tags')
+        self.cmd(f'--repo={self.repository_location}', 'recreate', 'test', '--exclude-caches', '--keep-exclude-tags')
         # if issue #4911 is present, the recreate will crash with a KeyError for "input/file1"
 
     @pytest.mark.skipif(not xattr.XATTR_FAKEROOT, reason='Linux capabilities test, requires fakeroot >= 1.20.2')
@@ -1579,10 +1579,10 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         assert 'Comment: \n' in self.cmd(f'--repo={self.repository_location}', 'info', '--name=test1')
         assert 'Comment: this is the comment' in self.cmd(f'--repo={self.repository_location}', 'info', '--name=test2')
 
-        self.cmd(f'--repo={self.repository_location}', 'recreate', '--name=test1', '--comment', 'added comment')
-        self.cmd(f'--repo={self.repository_location}', 'recreate', '--name=test2', '--comment', 'modified comment')
-        self.cmd(f'--repo={self.repository_location}', 'recreate', '--name=test3', '--comment', '')
-        self.cmd(f'--repo={self.repository_location}', 'recreate', '--name=test4', '12345')
+        self.cmd(f'--repo={self.repository_location}', 'recreate', '-a', 'test1', '--comment', 'added comment')
+        self.cmd(f'--repo={self.repository_location}', 'recreate', '-a', 'test2', '--comment', 'modified comment')
+        self.cmd(f'--repo={self.repository_location}', 'recreate', '-a', 'test3', '--comment', '')
+        self.cmd(f'--repo={self.repository_location}', 'recreate', '-a', 'test4', '12345')
         assert 'Comment: added comment' in self.cmd(f'--repo={self.repository_location}', 'info', '--name=test1')
         assert 'Comment: modified comment' in self.cmd(f'--repo={self.repository_location}', 'info', '--name=test2')
         assert 'Comment: \n' in self.cmd(f'--repo={self.repository_location}', 'info', '--name=test3')
@@ -2921,7 +2921,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self.cmd(f'--repo={self.repository_location}', 'create', 'test0', 'input')
         self.check_cache()
         original_archive = self.cmd(f'--repo={self.repository_location}', 'list')
-        self.cmd(f'--repo={self.repository_location}', 'recreate', '--name=test0', 'input/dir2',
+        self.cmd(f'--repo={self.repository_location}', 'recreate', 'test0', 'input/dir2',
                  '-e', 'input/dir2/file3', '--target=new-archive')
         self.check_cache()
         archives = self.cmd(f'--repo={self.repository_location}', 'list')
@@ -2938,7 +2938,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self.create_regular_file('dir2/file3', size=1024 * 80)
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
         self.cmd(f'--repo={self.repository_location}', 'create', 'test0', 'input')
-        self.cmd(f'--repo={self.repository_location}', 'recreate', '--name=test0', 'input/dir2', '-e', 'input/dir2/file3')
+        self.cmd(f'--repo={self.repository_location}', 'recreate', 'test0', 'input/dir2', '-e', 'input/dir2/file3')
         self.check_cache()
         listing = self.cmd(f'--repo={self.repository_location}', 'list', '--name=test0', '--short')
         assert 'file1' not in listing
@@ -2950,7 +2950,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         # This is essentially the same problem set as in test_extract_hardlinks
         self._extract_hardlinks_setup()
         self.cmd(f'--repo={self.repository_location}', 'create', 'test2', 'input')
-        self.cmd(f'--repo={self.repository_location}', 'recreate', '--name=test', 'input/dir1')
+        self.cmd(f'--repo={self.repository_location}', 'recreate', '-a', 'test', 'input/dir1')
         self.check_cache()
         with changedir('output'):
             self.cmd(f'--repo={self.repository_location}', 'extract', '--name=test')
@@ -3000,7 +3000,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self.create_test_files()
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
         self.cmd(f'--repo={self.repository_location}', 'create', 'test0', 'input')
-        self.cmd(f'--repo={self.repository_location}', 'recreate', '--name=test0', '--timestamp', "1970-01-02T00:00:00",
+        self.cmd(f'--repo={self.repository_location}', 'recreate', 'test0', '--timestamp', "1970-01-02T00:00:00",
                  '--comment', 'test')
         info = self.cmd(f'--repo={self.repository_location}', 'info', '--name=test0').splitlines()
         dtime = datetime(1970, 1, 2) + local_timezone.utcoffset(None)
@@ -3044,22 +3044,22 @@ class ArchiverTestCase(ArchiverTestCaseBase):
 
         self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
 
-        output = self.cmd(f'--repo={self.repository_location}', 'recreate', '--name=test', '--list', '--info', '-e', 'input/file2')
+        output = self.cmd(f'--repo={self.repository_location}', 'recreate', '-a', 'test', '--list', '--info', '-e', 'input/file2')
         self.check_cache()
         self.assert_in("input/file1", output)
         self.assert_in("x input/file2", output)
 
-        output = self.cmd(f'--repo={self.repository_location}', 'recreate', '--name=test', '--list', '-e', 'input/file3')
+        output = self.cmd(f'--repo={self.repository_location}', 'recreate', '-a', 'test', '--list', '-e', 'input/file3')
         self.check_cache()
         self.assert_in("input/file1", output)
         self.assert_in("x input/file3", output)
 
-        output = self.cmd(f'--repo={self.repository_location}', 'recreate', '--name=test', '-e', 'input/file4')
+        output = self.cmd(f'--repo={self.repository_location}', 'recreate', '-a', 'test', '-e', 'input/file4')
         self.check_cache()
         self.assert_not_in("input/file1", output)
         self.assert_not_in("x input/file4", output)
 
-        output = self.cmd(f'--repo={self.repository_location}', 'recreate', '--name=test', '--info', '-e', 'input/file5')
+        output = self.cmd(f'--repo={self.repository_location}', 'recreate', '-a', 'test', '--info', '-e', 'input/file5')
         self.check_cache()
         self.assert_not_in("input/file1", output)
         self.assert_not_in("x input/file5", output)

From b8c7c53dde1df9cbf69566606d796f2a3f606352 Mon Sep 17 00:00:00 2001
From: Thomas Waldmann <tw@waldmann-edv.de>
Date: Mon, 20 Jun 2022 16:04:58 +0200
Subject: [PATCH 058/160] borg extract NAME ...

---
 src/borg/archiver.py            |   6 +-
 src/borg/testsuite/archiver.py  | 162 ++++++++++++++++----------------
 src/borg/testsuite/benchmark.py |   2 +-
 3 files changed, 85 insertions(+), 85 deletions(-)

diff --git a/src/borg/archiver.py b/src/borg/archiver.py
index f82b4726b..8dd84d56a 100644
--- a/src/borg/archiver.py
+++ b/src/borg/archiver.py
@@ -691,7 +691,7 @@ class Archiver:
             assert rc1 == rc2 == 0
             # measure extraction (dry-run: without writing result to disk)
             t_start = time.monotonic()
-            rc = self.do_extract(self.parse_args([f'--repo={repo}', 'extract', '--name=borg-benchmark-crud1',
+            rc = self.do_extract(self.parse_args([f'--repo={repo}', 'extract', 'borg-benchmark-crud1',
                                                   '--dry-run']))
             t_end = time.monotonic()
             dt_extract = t_end - t_start
@@ -4312,8 +4312,6 @@ class Archiver:
                                           formatter_class=argparse.RawDescriptionHelpFormatter,
                                           help='extract archive contents')
         subparser.set_defaults(func=self.do_extract)
-        subparser.add_argument('--name', dest='name', metavar='NAME', type=NameSpec,
-                               help='specify the archive name')
         subparser.add_argument('--list', dest='output_list', action='store_true',
                                help='output verbose list of items (files, dirs, ...)')
         subparser.add_argument('-n', '--dry-run', dest='dry_run', action='store_true',
@@ -4334,6 +4332,8 @@ class Archiver:
                                help='write all extracted data to stdout')
         subparser.add_argument('--sparse', dest='sparse', action='store_true',
                                help='create holes in output sparse file from all-zero chunks')
+        subparser.add_argument('name', metavar='NAME', type=NameSpec,
+                               help='specify the archive name')
         subparser.add_argument('paths', metavar='PATH', nargs='*', type=str,
                                help='paths to extract; patterns are supported')
         define_exclusion_group(subparser, strip_components=True)
diff --git a/src/borg/testsuite/archiver.py b/src/borg/testsuite/archiver.py
index b9c18ec22..5093ee511 100644
--- a/src/borg/testsuite/archiver.py
+++ b/src/borg/testsuite/archiver.py
@@ -152,9 +152,9 @@ def test_return_codes(cmd, tmpdir):
     rc, out = cmd('--repo=%s' % repo, 'create', 'archive', str(input))
     assert rc == EXIT_SUCCESS
     with changedir(str(output)):
-        rc, out = cmd('--repo=%s' % repo, 'extract', '--name=archive')
+        rc, out = cmd('--repo=%s' % repo, 'extract', 'archive')
         assert rc == EXIT_SUCCESS
-    rc, out = cmd('--repo=%s' % repo, 'extract', '--name=archive', 'does/not/match')
+    rc, out = cmd('--repo=%s' % repo, 'extract', 'archive', 'does/not/match')
     assert rc == EXIT_WARNING  # pattern did not match
     rc, out = cmd('--repo=%s' % repo, 'create', 'archive', str(input))
     assert rc == EXIT_ERROR  # duplicate archive name
@@ -399,7 +399,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self.assert_in('Archive name: test.2', output)
         self.assert_in('This archive: ', output)
         with changedir('output'):
-            self.cmd(f'--repo={self.repository_location}', 'extract', '--name=test')
+            self.cmd(f'--repo={self.repository_location}', 'extract', 'test')
         list_output = self.cmd(f'--repo={self.repository_location}', 'list', '--short')
         self.assert_in('test', list_output)
         self.assert_in('test.2', list_output)
@@ -494,7 +494,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
         sock.close()
         with changedir('output'):
-            self.cmd(f'--repo={self.repository_location}', 'extract', '--name=test')
+            self.cmd(f'--repo={self.repository_location}', 'extract', 'test')
             assert not os.path.exists('input/unix-socket')
 
     @pytest.mark.skipif(not are_symlinks_supported(), reason='symlinks not supported')
@@ -503,7 +503,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
         self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
         with changedir('output'):
-            self.cmd(f'--repo={self.repository_location}', 'extract', '--name=test')
+            self.cmd(f'--repo={self.repository_location}', 'extract', 'test')
             assert os.readlink('input/link1') == 'somewhere'
 
     @pytest.mark.skipif(not are_symlinks_supported() or not are_hardlinks_supported(),
@@ -516,7 +516,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
         self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
         with changedir('output'):
-            output = self.cmd(f'--repo={self.repository_location}', 'extract', '--name=test')
+            output = self.cmd(f'--repo={self.repository_location}', 'extract', 'test')
             print(output)
             with changedir('input'):
                 assert os.path.exists('target')
@@ -550,7 +550,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
         self.cmd(f'--repo={self.repository_location}', 'create', '--atime', 'test', 'input')
         with changedir('output'):
-            self.cmd(f'--repo={self.repository_location}', 'extract', '--name=test')
+            self.cmd(f'--repo={self.repository_location}', 'extract', 'test')
         sti = os.stat('input/file1')
         sto = os.stat('output/input/file1')
         assert sti.st_mtime_ns == sto.st_mtime_ns == mtime * 1e9
@@ -570,7 +570,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
         self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
         with changedir('output'):
-            self.cmd(f'--repo={self.repository_location}', 'extract', '--name=test')
+            self.cmd(f'--repo={self.repository_location}', 'extract', 'test')
         sti = os.stat('input/file1')
         sto = os.stat('output/input/file1')
         assert int(sti.st_birthtime * 1e9) == int(sto.st_birthtime * 1e9) == birthtime * 1e9
@@ -586,7 +586,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
         self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input', '--nobirthtime')
         with changedir('output'):
-            self.cmd(f'--repo={self.repository_location}', 'extract', '--name=test')
+            self.cmd(f'--repo={self.repository_location}', 'extract', 'test')
         sti = os.stat('input/file1')
         sto = os.stat('output/input/file1')
         assert int(sti.st_birthtime * 1e9) == birthtime * 1e9
@@ -647,7 +647,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
             self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
             self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
             with changedir(self.output_path):
-                self.cmd(f'--repo={self.repository_location}', 'extract', '--name=test', '--sparse')
+                self.cmd(f'--repo={self.repository_location}', 'extract', 'test', '--sparse')
             self.assert_dirs_equal('input', 'output/input')
             filename = os.path.join(self.output_path, 'input', 'sparse')
             with open(filename, 'rb') as fd:
@@ -667,7 +667,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
         for filename in filenames:
             with changedir('output'):
-                self.cmd(f'--repo={self.repository_location}', 'extract', '--name=test', os.path.join('input', filename))
+                self.cmd(f'--repo={self.repository_location}', 'extract', 'test', os.path.join('input', filename))
             assert os.path.exists(os.path.join('output', 'input', filename))
 
     def test_repository_swap_detection(self):
@@ -807,14 +807,14 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self.create_regular_file('dir/file')
         self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
         with changedir('output'):
-            self.cmd(f'--repo={self.repository_location}', 'extract', '--name=test', '--strip-components', '3')
+            self.cmd(f'--repo={self.repository_location}', 'extract', 'test', '--strip-components', '3')
             assert not os.path.exists('file')
             with self.assert_creates_file('file'):
-                self.cmd(f'--repo={self.repository_location}', 'extract', '--name=test', '--strip-components', '2')
+                self.cmd(f'--repo={self.repository_location}', 'extract', 'test', '--strip-components', '2')
             with self.assert_creates_file('dir/file'):
-                self.cmd(f'--repo={self.repository_location}', 'extract', '--name=test', '--strip-components', '1')
+                self.cmd(f'--repo={self.repository_location}', 'extract', 'test', '--strip-components', '1')
             with self.assert_creates_file('input/dir/file'):
-                self.cmd(f'--repo={self.repository_location}', 'extract', '--name=test', '--strip-components', '0')
+                self.cmd(f'--repo={self.repository_location}', 'extract', 'test', '--strip-components', '0')
 
     def _extract_hardlinks_setup(self):
         os.mkdir(os.path.join(self.input_path, 'dir1'))
@@ -873,7 +873,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
     def test_extract_hardlinks1(self):
         self._extract_hardlinks_setup()
         with changedir('output'):
-            self.cmd(f'--repo={self.repository_location}', 'extract', '--name=test')
+            self.cmd(f'--repo={self.repository_location}', 'extract', 'test')
             assert os.stat('input/source').st_nlink == 4
             assert os.stat('input/abba').st_nlink == 4
             assert os.stat('input/dir1/hardlink').st_nlink == 4
@@ -884,14 +884,14 @@ class ArchiverTestCase(ArchiverTestCaseBase):
     def test_extract_hardlinks2(self):
         self._extract_hardlinks_setup()
         with changedir('output'):
-            self.cmd(f'--repo={self.repository_location}', 'extract', '--name=test', '--strip-components', '2')
+            self.cmd(f'--repo={self.repository_location}', 'extract', 'test', '--strip-components', '2')
             assert os.stat('hardlink').st_nlink == 2
             assert os.stat('subdir/hardlink').st_nlink == 2
             assert open('subdir/hardlink', 'rb').read() == b'123456'
             assert os.stat('aaaa').st_nlink == 2
             assert os.stat('source2').st_nlink == 2
         with changedir('output'):
-            self.cmd(f'--repo={self.repository_location}', 'extract', '--name=test', 'input/dir1')
+            self.cmd(f'--repo={self.repository_location}', 'extract', 'test', 'input/dir1')
             assert os.stat('input/dir1/hardlink').st_nlink == 2
             assert os.stat('input/dir1/subdir/hardlink').st_nlink == 2
             assert open('input/dir1/subdir/hardlink', 'rb').read() == b'123456'
@@ -913,7 +913,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input', 'input')  # give input twice!
         # now test extraction
         with changedir('output'):
-            self.cmd(f'--repo={self.repository_location}', 'extract', '--name=test')
+            self.cmd(f'--repo={self.repository_location}', 'extract', 'test')
             # if issue #5603 happens, extraction gives rc == 1 (triggering AssertionError) and warnings like:
             # input/a/hardlink: link: [Errno 2] No such file or directory: 'input/a/hardlink' -> 'input/a/hardlink'
             # input/b/hardlink: link: [Errno 2] No such file or directory: 'input/a/hardlink' -> 'input/b/hardlink'
@@ -929,13 +929,13 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self.create_regular_file('file4', size=1024 * 80)
         self.cmd(f'--repo={self.repository_location}', 'create', '--exclude=input/file4', 'test', 'input')
         with changedir('output'):
-            self.cmd(f'--repo={self.repository_location}', 'extract', '--name=test', 'input/file1', )
+            self.cmd(f'--repo={self.repository_location}', 'extract', 'test', 'input/file1', )
         self.assert_equal(sorted(os.listdir('output/input')), ['file1'])
         with changedir('output'):
-            self.cmd(f'--repo={self.repository_location}', 'extract', '--name=test', '--exclude=input/file2')
+            self.cmd(f'--repo={self.repository_location}', 'extract', 'test', '--exclude=input/file2')
         self.assert_equal(sorted(os.listdir('output/input')), ['file1', 'file3'])
         with changedir('output'):
-            self.cmd(f'--repo={self.repository_location}', 'extract', '--name=test', '--exclude-from=' + self.exclude_file_path)
+            self.cmd(f'--repo={self.repository_location}', 'extract', 'test', '--exclude-from=' + self.exclude_file_path)
         self.assert_equal(sorted(os.listdir('output/input')), ['file1', 'file3'])
 
     def test_extract_include_exclude_regex(self):
@@ -949,25 +949,25 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         # Create with regular expression exclusion for file4
         self.cmd(f'--repo={self.repository_location}', 'create', '--exclude=re:input/file4$', 'test', 'input')
         with changedir('output'):
-            self.cmd(f'--repo={self.repository_location}', 'extract', '--name=test')
+            self.cmd(f'--repo={self.repository_location}', 'extract', 'test')
         self.assert_equal(sorted(os.listdir('output/input')), ['file1', 'file2', 'file3', 'file333'])
         shutil.rmtree('output/input')
 
         # Extract with regular expression exclusion
         with changedir('output'):
-            self.cmd(f'--repo={self.repository_location}', 'extract', '--name=test', '--exclude=re:file3+')
+            self.cmd(f'--repo={self.repository_location}', 'extract', 'test', '--exclude=re:file3+')
         self.assert_equal(sorted(os.listdir('output/input')), ['file1', 'file2'])
         shutil.rmtree('output/input')
 
         # Combine --exclude with fnmatch and regular expression
         with changedir('output'):
-            self.cmd(f'--repo={self.repository_location}', 'extract', '--name=test', '--exclude=input/file2', '--exclude=re:file[01]')
+            self.cmd(f'--repo={self.repository_location}', 'extract', 'test', '--exclude=input/file2', '--exclude=re:file[01]')
         self.assert_equal(sorted(os.listdir('output/input')), ['file3', 'file333'])
         shutil.rmtree('output/input')
 
         # Combine --exclude-from and regular expression exclusion
         with changedir('output'):
-            self.cmd(f'--repo={self.repository_location}', 'extract', '--name=test', '--exclude-from=' + self.exclude_file_path,
+            self.cmd(f'--repo={self.repository_location}', 'extract', 'test', '--exclude-from=' + self.exclude_file_path,
                      '--exclude=re:file1', '--exclude=re:file(\\d)\\1\\1$')
         self.assert_equal(sorted(os.listdir('output/input')), ['file3'])
 
@@ -987,7 +987,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
 
         self.cmd(f'--repo={self.repository_location}', 'create', '--exclude-from=' + self.exclude_file_path, 'test', 'input')
         with changedir('output'):
-            self.cmd(f'--repo={self.repository_location}', 'extract', '--name=test')
+            self.cmd(f'--repo={self.repository_location}', 'extract', 'test')
         self.assert_equal(sorted(os.listdir('output/input')), ['file1', 'file2', 'file3', 'file333'])
         shutil.rmtree('output/input')
 
@@ -996,7 +996,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
             fd.write(b're:file3+\n')
 
         with changedir('output'):
-            self.cmd(f'--repo={self.repository_location}', 'extract', '--name=test', '--exclude-from=' + self.exclude_file_path)
+            self.cmd(f'--repo={self.repository_location}', 'extract', 'test', '--exclude-from=' + self.exclude_file_path)
         self.assert_equal(sorted(os.listdir('output/input')), ['file1', 'file2'])
         shutil.rmtree('output/input')
 
@@ -1008,7 +1008,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
             fd.write(b're:file2$\n')
 
         with changedir('output'):
-            self.cmd(f'--repo={self.repository_location}', 'extract', '--name=test', '--exclude-from=' + self.exclude_file_path)
+            self.cmd(f'--repo={self.repository_location}', 'extract', 'test', '--exclude-from=' + self.exclude_file_path)
         self.assert_equal(sorted(os.listdir('output/input')), ['file3'])
 
     def test_extract_with_pattern(self):
@@ -1023,25 +1023,25 @@ class ArchiverTestCase(ArchiverTestCaseBase):
 
         # Extract everything with regular expression
         with changedir("output"):
-            self.cmd(f'--repo={self.repository_location}', "extract", "--name=test", "re:.*")
+            self.cmd(f'--repo={self.repository_location}', "extract", "test", "re:.*")
         self.assert_equal(sorted(os.listdir("output/input")), ["file1", "file2", "file3", "file333", "file4"])
         shutil.rmtree("output/input")
 
         # Extract with pattern while also excluding files
         with changedir("output"):
-            self.cmd(f'--repo={self.repository_location}', "extract", "--name=test", "--exclude=re:file[34]$", r"re:file\d$")
+            self.cmd(f'--repo={self.repository_location}', "extract", "--exclude=re:file[34]$", "test", r"re:file\d$")
         self.assert_equal(sorted(os.listdir("output/input")), ["file1", "file2"])
         shutil.rmtree("output/input")
 
         # Combine --exclude with pattern for extraction
         with changedir("output"):
-            self.cmd(f'--repo={self.repository_location}', "extract", "--name=test", "--exclude=input/file1", "re:file[12]$")
+            self.cmd(f'--repo={self.repository_location}', "extract", "--exclude=input/file1", "test", "re:file[12]$")
         self.assert_equal(sorted(os.listdir("output/input")), ["file2"])
         shutil.rmtree("output/input")
 
         # Multiple pattern
         with changedir("output"):
-            self.cmd(f'--repo={self.repository_location}', "extract", "--name=test", "fm:input/file1", "fm:*file33*", "input/file2")
+            self.cmd(f'--repo={self.repository_location}', "extract", "test", "fm:input/file1", "fm:*file33*", "input/file2")
         self.assert_equal(sorted(os.listdir("output/input")), ["file1", "file2", "file333"])
 
     def test_extract_list_output(self):
@@ -1051,22 +1051,22 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
 
         with changedir('output'):
-            output = self.cmd(f'--repo={self.repository_location}', 'extract', '--name=test')
+            output = self.cmd(f'--repo={self.repository_location}', 'extract', 'test')
         self.assert_not_in("input/file", output)
         shutil.rmtree('output/input')
 
         with changedir('output'):
-            output = self.cmd(f'--repo={self.repository_location}', 'extract', '--name=test', '--info')
+            output = self.cmd(f'--repo={self.repository_location}', 'extract', 'test', '--info')
         self.assert_not_in("input/file", output)
         shutil.rmtree('output/input')
 
         with changedir('output'):
-            output = self.cmd(f'--repo={self.repository_location}', 'extract', '--name=test', '--list')
+            output = self.cmd(f'--repo={self.repository_location}', 'extract', 'test', '--list')
         self.assert_in("input/file", output)
         shutil.rmtree('output/input')
 
         with changedir('output'):
-            output = self.cmd(f'--repo={self.repository_location}', 'extract', '--name=test', '--list', '--info')
+            output = self.cmd(f'--repo={self.repository_location}', 'extract', 'test', '--list', '--info')
         self.assert_in("input/file", output)
 
     def test_extract_progress(self):
@@ -1075,7 +1075,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
 
         with changedir('output'):
-            output = self.cmd(f'--repo={self.repository_location}', 'extract', '--name=test', '--progress')
+            output = self.cmd(f'--repo={self.repository_location}', 'extract', 'test', '--progress')
             assert 'Extracting:' in output
 
     def _create_test_caches(self):
@@ -1101,7 +1101,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         assert item['gid'] == 0
         assert item['size'] == len(input_data)
         assert item['path'] == 'stdin'
-        extracted_data = self.cmd(f'--repo={self.repository_location}', 'extract', '--name=test', '--stdout', binary_output=True)
+        extracted_data = self.cmd(f'--repo={self.repository_location}', 'extract', 'test', '--stdout', binary_output=True)
         assert extracted_data == input_data
 
     def test_create_content_from_command(self):
@@ -1115,7 +1115,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         assert item['gid'] == 0
         assert item['size'] == len(input_data) + 1  # `echo` adds newline
         assert item['path'] == name
-        extracted_data = self.cmd(f'--repo={self.repository_location}', 'extract', '--name=test', '--stdout')
+        extracted_data = self.cmd(f'--repo={self.repository_location}', 'extract', 'test', '--stdout')
         assert extracted_data == input_data + '\n'
 
     def test_create_content_from_command_with_failed_command(self):
@@ -1296,13 +1296,13 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self.create_regular_file('file_important', size=1024 * 80)
         self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
         with changedir('output'):
-            self.cmd(f'--repo={self.repository_location}', 'extract', '--name=test',
+            self.cmd(f'--repo={self.repository_location}', 'extract', 'test',
                      '--pattern=+input/file_important', '--pattern=-input/file*')
         self.assert_equal(sorted(os.listdir('output/input')), ['file_important'])
 
     def _assert_test_caches(self):
         with changedir('output'):
-            self.cmd(f'--repo={self.repository_location}', 'extract', '--name=test')
+            self.cmd(f'--repo={self.repository_location}', 'extract', 'test')
         self.assert_equal(sorted(os.listdir('output/input')), ['cache2', 'file1'])
         self.assert_equal(sorted(os.listdir('output/input/cache2')), [CACHE_TAG_NAME])
 
@@ -1326,7 +1326,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
 
     def _assert_test_tagged(self):
         with changedir('output'):
-            self.cmd(f'--repo={self.repository_location}', 'extract', '--name=test')
+            self.cmd(f'--repo={self.repository_location}', 'extract', 'test')
         self.assert_equal(sorted(os.listdir('output/input')), ['file1'])
 
     def test_exclude_tagged(self):
@@ -1360,7 +1360,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
 
     def _assert_test_keep_tagged(self):
         with changedir('output'):
-            self.cmd(f'--repo={self.repository_location}', 'extract', '--name=test')
+            self.cmd(f'--repo={self.repository_location}', 'extract', 'test')
         self.assert_equal(sorted(os.listdir('output/input')), ['file0', 'tagged1', 'tagged2', 'tagged3', 'taggedall'])
         self.assert_equal(os.listdir('output/input/tagged1'), ['.NOBACKUP1'])
         self.assert_equal(os.listdir('output/input/tagged2'), ['.NOBACKUP2'])
@@ -1413,7 +1413,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
         with changedir('output'):
             with patch.object(os, 'fchown', patched_fchown):
-                self.cmd(f'--repo={self.repository_location}', 'extract', '--name=test')
+                self.cmd(f'--repo={self.repository_location}', 'extract', 'test')
             assert xattr.getxattr(b'input/file', b'security.capability') == capabilities
 
     @pytest.mark.skipif(not xattr.XATTR_FAKEROOT, reason='xattr not supported on this system or on this version of'
@@ -1435,15 +1435,15 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         with changedir('output'):
             input_abspath = os.path.abspath('input/file')
             with patch.object(xattr, 'setxattr', patched_setxattr_E2BIG):
-                out = self.cmd(f'--repo={self.repository_location}', 'extract', '--name=test', exit_code=EXIT_WARNING)
+                out = self.cmd(f'--repo={self.repository_location}', 'extract', 'test', exit_code=EXIT_WARNING)
                 assert ': when setting extended attribute user.attribute: too big for this filesystem\n' in out
             os.remove(input_abspath)
             with patch.object(xattr, 'setxattr', patched_setxattr_ENOTSUP):
-                out = self.cmd(f'--repo={self.repository_location}', 'extract', '--name=test', exit_code=EXIT_WARNING)
+                out = self.cmd(f'--repo={self.repository_location}', 'extract', 'test', exit_code=EXIT_WARNING)
                 assert ': when setting extended attribute user.attribute: xattrs not supported on this filesystem\n' in out
             os.remove(input_abspath)
             with patch.object(xattr, 'setxattr', patched_setxattr_EACCES):
-                out = self.cmd(f'--repo={self.repository_location}', 'extract', '--name=test', exit_code=EXIT_WARNING)
+                out = self.cmd(f'--repo={self.repository_location}', 'extract', 'test', exit_code=EXIT_WARNING)
                 assert ': when setting extended attribute user.attribute: Permission denied\n' in out
             assert os.path.isfile(input_abspath)
 
@@ -1464,16 +1464,16 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         with changedir('input'):
             self.cmd(f'--repo={self.repository_location}', 'create', 'test1', '.', '--exclude=file1')
         with changedir('output'):
-            self.cmd(f'--repo={self.repository_location}', 'extract', '--name=test1')
+            self.cmd(f'--repo={self.repository_location}', 'extract', 'test1')
         self.assert_equal(sorted(os.listdir('output')), ['file2'])
         with changedir('input'):
             self.cmd(f'--repo={self.repository_location}', 'create', 'test2', '.', '--exclude=./file1')
         with changedir('output'):
-            self.cmd(f'--repo={self.repository_location}', 'extract', '--name=test2')
+            self.cmd(f'--repo={self.repository_location}', 'extract', 'test2')
         self.assert_equal(sorted(os.listdir('output')), ['file2'])
         self.cmd(f'--repo={self.repository_location}', 'create', 'test3', 'input', '--exclude=input/./file1')
         with changedir('output'):
-            self.cmd(f'--repo={self.repository_location}', 'extract', '--name=test3')
+            self.cmd(f'--repo={self.repository_location}', 'extract', 'test3')
         self.assert_equal(sorted(os.listdir('output/input')), ['file2'])
 
     def test_repeated_files(self):
@@ -1491,14 +1491,14 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         os.mkdir('output/input/file1')
         os.mkdir('output/input/dir2')
         with changedir('output'):
-            self.cmd(f'--repo={self.repository_location}', 'extract', '--name=test')
+            self.cmd(f'--repo={self.repository_location}', 'extract', 'test')
         self.assert_dirs_equal('input', 'output/input')
         # But non-empty dirs should fail
         os.unlink('output/input/file1')
         os.mkdir('output/input/file1')
         os.mkdir('output/input/file1/dir')
         with changedir('output'):
-            self.cmd(f'--repo={self.repository_location}', 'extract', '--name=test', exit_code=1)
+            self.cmd(f'--repo={self.repository_location}', 'extract', 'test', exit_code=1)
 
     def test_rename(self):
         self.create_regular_file('file1', size=1024 * 80)
@@ -1506,13 +1506,13 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
         self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
         self.cmd(f'--repo={self.repository_location}', 'create', 'test.2', 'input')
-        self.cmd(f'--repo={self.repository_location}', 'extract', '--name=test', '--dry-run')
-        self.cmd(f'--repo={self.repository_location}', 'extract', '--name=test.2', '--dry-run')
+        self.cmd(f'--repo={self.repository_location}', 'extract', 'test', '--dry-run')
+        self.cmd(f'--repo={self.repository_location}', 'extract', 'test.2', '--dry-run')
         self.cmd(f'--repo={self.repository_location}', 'rename', 'test', 'test.3')
-        self.cmd(f'--repo={self.repository_location}', 'extract', '--name=test.2', '--dry-run')
+        self.cmd(f'--repo={self.repository_location}', 'extract', 'test.2', '--dry-run')
         self.cmd(f'--repo={self.repository_location}', 'rename', 'test.2', 'test.4')
-        self.cmd(f'--repo={self.repository_location}', 'extract', '--name=test.3', '--dry-run')
-        self.cmd(f'--repo={self.repository_location}', 'extract', '--name=test.4', '--dry-run')
+        self.cmd(f'--repo={self.repository_location}', 'extract', 'test.3', '--dry-run')
+        self.cmd(f'--repo={self.repository_location}', 'extract', 'test.4', '--dry-run')
         # Make sure both archives have been renamed
         with Repository(self.repository_path) as repository:
             manifest, key = Manifest.load(repository, Manifest.NO_OPERATION_CHECK)
@@ -1597,12 +1597,12 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self.cmd(f'--repo={self.repository_location}', 'create', 'test.3', 'input')
         self.cmd(f'--repo={self.repository_location}', 'create', 'another_test.1', 'input')
         self.cmd(f'--repo={self.repository_location}', 'create', 'another_test.2', 'input')
-        self.cmd(f'--repo={self.repository_location}', 'extract', '--name=test', '--dry-run')
-        self.cmd(f'--repo={self.repository_location}', 'extract', '--name=test.2', '--dry-run')
+        self.cmd(f'--repo={self.repository_location}', 'extract', 'test', '--dry-run')
+        self.cmd(f'--repo={self.repository_location}', 'extract', 'test.2', '--dry-run')
         self.cmd(f'--repo={self.repository_location}', 'delete', '--prefix', 'another_')
         self.cmd(f'--repo={self.repository_location}', 'delete', '--last', '1')
         self.cmd(f'--repo={self.repository_location}', 'delete', '--name=test')
-        self.cmd(f'--repo={self.repository_location}', 'extract', '--name=test.2', '--dry-run')
+        self.cmd(f'--repo={self.repository_location}', 'extract', 'test.2', '--dry-run')
         output = self.cmd(f'--repo={self.repository_location}', 'delete', '--name=test.2', '--stats')
         self.assert_in('Deleted data:', output)
         # Make sure all data except the manifest has been deleted
@@ -1616,7 +1616,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self.cmd(f'--repo={self.repository_location}', 'create', 'test2', 'input')
         self.cmd(f'--repo={self.repository_location}', 'create', 'test3', 'input')
         self.cmd(f'--repo={self.repository_location}', 'delete', '--name=test1', 'test2')
-        self.cmd(f'--repo={self.repository_location}', 'extract', '--name=test3', '--dry-run')
+        self.cmd(f'--repo={self.repository_location}', 'extract', 'test3', '--dry-run')
         self.cmd(f'--repo={self.repository_location}', 'delete', '--name=test3')
         assert not self.cmd(f'--repo={self.repository_location}', 'list')
 
@@ -1670,7 +1670,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
     def test_corrupted_repository(self):
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
         self.create_src_archive('test')
-        self.cmd(f'--repo={self.repository_location}', 'extract', '--name=test', '--dry-run')
+        self.cmd(f'--repo={self.repository_location}', 'extract', 'test', '--dry-run')
         output = self.cmd(f'--repo={self.repository_location}', 'check', '--show-version')
         self.assert_in('borgbackup version', output)  # implied output even without --info given
         self.assert_not_in('Starting repository check', output)  # --info not given for root logger
@@ -1734,14 +1734,14 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         with self.read_only(self.repository_path):
             # verify that command normally doesn't work with read-only repo
             if self.FORK_DEFAULT:
-                self.cmd(f'--repo={self.repository_location}', 'extract', '--name=test', exit_code=EXIT_ERROR)
+                self.cmd(f'--repo={self.repository_location}', 'extract', 'test', exit_code=EXIT_ERROR)
             else:
                 with pytest.raises((LockFailed, RemoteRepository.RPCError)) as excinfo:
-                    self.cmd(f'--repo={self.repository_location}', 'extract', '--name=test')
+                    self.cmd(f'--repo={self.repository_location}', 'extract', 'test')
                 if isinstance(excinfo.value, RemoteRepository.RPCError):
                     assert excinfo.value.exception_class == 'LockFailed'
             # verify that command works with read-only repo when using --bypass-lock
-            self.cmd(f'--repo={self.repository_location}', 'extract', '--name=test', '--bypass-lock')
+            self.cmd(f'--repo={self.repository_location}', 'extract', 'test', '--bypass-lock')
 
     def test_readonly_info(self):
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
@@ -1845,7 +1845,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
         self.add_unknown_feature(Manifest.Operation.READ)
         with changedir('output'):
-            self.cmd_raises_unknown_feature([f'--repo={self.repository_location}', 'extract', '--name=test'])
+            self.cmd_raises_unknown_feature([f'--repo={self.repository_location}', 'extract', 'test'])
 
         self.cmd_raises_unknown_feature([f'--repo={self.repository_location}', 'list'])
         self.cmd_raises_unknown_feature([f'--repo={self.repository_location}', 'info', '--name=test'])
@@ -2083,7 +2083,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         finally:
             t.join()
         with changedir('output'):
-            self.cmd(f'--repo={self.repository_location}', 'extract', '--name=test')
+            self.cmd(f'--repo={self.repository_location}', 'extract', 'test')
             fifo_fn = 'input/link_fifo'
             with open(fifo_fn, 'rb') as f:
                 extracted_data = f.read()
@@ -2953,13 +2953,13 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self.cmd(f'--repo={self.repository_location}', 'recreate', '-a', 'test', 'input/dir1')
         self.check_cache()
         with changedir('output'):
-            self.cmd(f'--repo={self.repository_location}', 'extract', '--name=test')
+            self.cmd(f'--repo={self.repository_location}', 'extract', 'test')
             assert os.stat('input/dir1/hardlink').st_nlink == 2
             assert os.stat('input/dir1/subdir/hardlink').st_nlink == 2
             assert os.stat('input/dir1/aaaa').st_nlink == 2
             assert os.stat('input/dir1/source2').st_nlink == 2
         with changedir('output'):
-            self.cmd(f'--repo={self.repository_location}', 'extract', '--name=test2')
+            self.cmd(f'--repo={self.repository_location}', 'extract', 'test2')
             assert os.stat('input/dir1/hardlink').st_nlink == 4
 
     def test_recreate_rechunkify(self):
@@ -3437,7 +3437,7 @@ id: 2 / e29442 3506da 4e1ea7 / 25f62a 5a3d41 - 02
         self.cmd(f'--repo={self.repository_location}', 'export-tar', '--name=src', 'simple.tar', f'--tar-format={tar_format}')
         self.cmd(f'--repo={self.repository_location}', 'import-tar', '--name=dst', 'simple.tar')
         with changedir(self.output_path):
-            self.cmd(f'--repo={self.repository_location}', 'extract', '--name=dst')
+            self.cmd(f'--repo={self.repository_location}', 'extract', 'dst')
         self.assert_dirs_equal('input', 'output/input', ignore_ns=True, ignore_xattrs=True)
 
     @requires_gzip
@@ -3451,7 +3451,7 @@ id: 2 / e29442 3506da 4e1ea7 / 25f62a 5a3d41 - 02
         self.cmd(f'--repo={self.repository_location}', 'export-tar', '--name=src', 'simple.tgz', f'--tar-format={tar_format}')
         self.cmd(f'--repo={self.repository_location}', 'import-tar', '--name=dst', 'simple.tgz')
         with changedir(self.output_path):
-            self.cmd(f'--repo={self.repository_location}', 'extract', '--name=dst')
+            self.cmd(f'--repo={self.repository_location}', 'extract', 'dst')
         self.assert_dirs_equal('input', 'output/input', ignore_ns=True, ignore_xattrs=True)
 
     def test_roundtrip_pax_borg(self):
@@ -3461,7 +3461,7 @@ id: 2 / e29442 3506da 4e1ea7 / 25f62a 5a3d41 - 02
         self.cmd(f'--repo={self.repository_location}', 'export-tar', '--name=src', 'simple.tar', '--tar-format=BORG')
         self.cmd(f'--repo={self.repository_location}', 'import-tar', '--name=dst', 'simple.tar')
         with changedir(self.output_path):
-            self.cmd(f'--repo={self.repository_location}', 'extract', '--name=dst')
+            self.cmd(f'--repo={self.repository_location}', 'extract', 'dst')
         self.assert_dirs_equal('input', 'output/input')
 
     # derived from test_extract_xattrs_errors()
@@ -3478,7 +3478,7 @@ id: 2 / e29442 3506da 4e1ea7 / 25f62a 5a3d41 - 02
         self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
         with changedir('output'):
             with patch.object(xattr, 'setxattr', patched_setxattr_EACCES):
-                self.cmd(f'--repo={self.repository_location}', 'extract', '--name=test', exit_code=EXIT_WARNING)
+                self.cmd(f'--repo={self.repository_location}', 'extract', 'test', exit_code=EXIT_WARNING)
 
     # derived from test_extract_xattrs_errors()
     @pytest.mark.skipif(not xattr.XATTR_FAKEROOT, reason='xattr not supported on this system or on this version of'
@@ -3494,7 +3494,7 @@ id: 2 / e29442 3506da 4e1ea7 / 25f62a 5a3d41 - 02
         self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
         with changedir('output'):
             with patch.object(xattr, 'setxattr', patched_setxattr_EACCES):
-                self.cmd(f'--repo={self.repository_location}', 'extract', '--name=test', exit_code=EXIT_WARNING)
+                self.cmd(f'--repo={self.repository_location}', 'extract', 'test', exit_code=EXIT_WARNING)
 
     def test_do_not_mention_archive_if_you_can_not_find_repo(self):
         """https://github.com/borgbackup/borg/issues/6014"""
@@ -3529,7 +3529,7 @@ id: 2 / e29442 3506da 4e1ea7 / 25f62a 5a3d41 - 02
         assert 'file1' in archive_list
         # Extracting the archive should work
         with changedir('output'):
-            self.cmd(f'--repo={self.repository_location}', 'extract', '--name=test')
+            self.cmd(f'--repo={self.repository_location}', 'extract', 'test')
         self.assert_dirs_equal('input', 'output/input')
 
     def test_recovery_from_deleted_repo_nonce(self):
@@ -3826,7 +3826,7 @@ class ArchiverCheckTestCase(ArchiverTestCaseBase):
         self.cmd(f'--repo={self.repository_location}', 'check', exit_code=1)
         self.cmd(f'--repo={self.repository_location}', 'check', '--repair', exit_code=0)
         self.cmd(f'--repo={self.repository_location}', 'check', exit_code=0)
-        self.cmd(f'--repo={self.repository_location}', 'extract', '--name=archive1', '--dry-run', exit_code=0)
+        self.cmd(f'--repo={self.repository_location}', 'extract', 'archive1', '--dry-run', exit_code=0)
 
     def _test_verify_data(self, *init_args):
         shutil.rmtree(self.repository_path)
@@ -3997,16 +3997,16 @@ class RemoteArchiverTestCase(ArchiverTestCase):
         self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
         marker = 'cached responses left in RemoteRepository'
         with changedir('output'):
-            res = self.cmd(f'--repo={self.repository_location}', 'extract', '--name=test', "--debug", '--strip-components', '3')
+            res = self.cmd(f'--repo={self.repository_location}', 'extract', 'test', "--debug", '--strip-components', '3')
             assert marker not in res
             with self.assert_creates_file('file'):
-                res = self.cmd(f'--repo={self.repository_location}', 'extract', '--name=test', "--debug", '--strip-components', '2')
+                res = self.cmd(f'--repo={self.repository_location}', 'extract', 'test', "--debug", '--strip-components', '2')
                 assert marker not in res
             with self.assert_creates_file('dir/file'):
-                res = self.cmd(f'--repo={self.repository_location}', 'extract', '--name=test', "--debug", '--strip-components', '1')
+                res = self.cmd(f'--repo={self.repository_location}', 'extract', 'test', "--debug", '--strip-components', '1')
                 assert marker not in res
             with self.assert_creates_file('input/dir/file'):
-                res = self.cmd(f'--repo={self.repository_location}', 'extract', '--name=test', "--debug", '--strip-components', '0')
+                res = self.cmd(f'--repo={self.repository_location}', 'extract', 'test', "--debug", '--strip-components', '0')
                 assert marker not in res
 
 
diff --git a/src/borg/testsuite/benchmark.py b/src/borg/testsuite/benchmark.py
index fac828c13..0a9a4373a 100644
--- a/src/borg/testsuite/benchmark.py
+++ b/src/borg/testsuite/benchmark.py
@@ -76,7 +76,7 @@ def test_create_lz4(benchmark, cmd, repo, testdata):
 def test_extract(benchmark, cmd, repo_archive, tmpdir):
     repo, archive = repo_archive
     with changedir(str(tmpdir)):
-        result, out = benchmark.pedantic(cmd, (f'--repo={repo}', 'extract', '--name', archive))
+        result, out = benchmark.pedantic(cmd, (f'--repo={repo}', 'extract', archive))
     assert result == 0
 
 

From 75b53de37ef2244180a35e693709ba08de1779e5 Mon Sep 17 00:00:00 2001
From: Thomas Waldmann <tw@waldmann-edv.de>
Date: Mon, 20 Jun 2022 16:50:36 +0200
Subject: [PATCH 059/160] borg diff ARCH1 ARCH2

---
 src/borg/archiver.py           |  6 +++---
 src/borg/testsuite/archiver.py | 14 +++++++-------
 2 files changed, 10 insertions(+), 10 deletions(-)

diff --git a/src/borg/archiver.py b/src/borg/archiver.py
index 8dd84d56a..b3bd9de68 100644
--- a/src/borg/archiver.py
+++ b/src/borg/archiver.py
@@ -1477,7 +1477,7 @@ class Archiver:
         print_output = print_json_output if args.json_lines else print_text_output
 
         archive1 = archive
-        archive2 = Archive(repository, key, manifest, args.name2,
+        archive2 = Archive(repository, key, manifest, args.other_name,
                            consider_part_files=args.consider_part_files)
 
         can_compare_chunk_ids = archive1.metadata.get('chunker_params', False) == archive2.metadata.get(
@@ -4206,10 +4206,10 @@ class Archiver:
                                help='Sort the output lines by file path.')
         subparser.add_argument('--json-lines', action='store_true',
                                help='Format output as JSON Lines. ')
-        subparser.add_argument('--name', metavar='ARCHIVE1',
+        subparser.add_argument('name', metavar='ARCHIVE1',
                                type=archivename_validator(),
                                help='ARCHIVE1 name')
-        subparser.add_argument('--name2', metavar='ARCHIVE2',
+        subparser.add_argument('other_name', metavar='ARCHIVE2',
                                type=archivename_validator(),
                                help='ARCHIVE2 name')
         subparser.add_argument('paths', metavar='PATH', nargs='*', type=str,
diff --git a/src/borg/testsuite/archiver.py b/src/borg/testsuite/archiver.py
index 5093ee511..f31813264 100644
--- a/src/borg/testsuite/archiver.py
+++ b/src/borg/testsuite/archiver.py
@@ -1704,14 +1704,14 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         with self.read_only(self.repository_path):
             # verify that command normally doesn't work with read-only repo
             if self.FORK_DEFAULT:
-                self.cmd(f'--repo={self.repository_location}', 'diff', '--name=a', '--name2=b', exit_code=EXIT_ERROR)
+                self.cmd(f'--repo={self.repository_location}', 'diff', 'a', 'b', exit_code=EXIT_ERROR)
             else:
                 with pytest.raises((LockFailed, RemoteRepository.RPCError)) as excinfo:
-                    self.cmd(f'--repo={self.repository_location}', 'diff', '--name=a', '--name=b')
+                    self.cmd(f'--repo={self.repository_location}', 'diff', 'a', 'b')
                 if isinstance(excinfo.value, RemoteRepository.RPCError):
                     assert excinfo.value.exception_class == 'LockFailed'
             # verify that command works with read-only repo when using --bypass-lock
-            self.cmd(f'--repo={self.repository_location}', 'diff', '--name=a', '--name2=b', '--bypass-lock')
+            self.cmd(f'--repo={self.repository_location}', 'diff', 'a', 'b', '--bypass-lock')
 
     def test_readonly_export_tar(self):
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
@@ -4288,10 +4288,10 @@ class DiffArchiverTestCase(ArchiverTestCaseBase):
             if are_hardlinks_supported():
                 assert not any(get_changes('input/hardlink_target_replaced', joutput))
 
-        do_asserts(self.cmd(f'--repo={self.repository_location}', 'diff', '--name=test0', '--name2=test1a'), True)
+        do_asserts(self.cmd(f'--repo={self.repository_location}', 'diff', 'test0', 'test1a'), True)
         # We expect exit_code=1 due to the chunker params warning
-        do_asserts(self.cmd(f'--repo={self.repository_location}', 'diff', '--name=test0', '--name2=test1b', exit_code=1), False)
-        do_json_asserts(self.cmd(f'--repo={self.repository_location}', 'diff', '--name=test0', '--name2=test1a', '--json-lines'), True)
+        do_asserts(self.cmd(f'--repo={self.repository_location}', 'diff', 'test0', 'test1b', exit_code=1), False)
+        do_json_asserts(self.cmd(f'--repo={self.repository_location}', 'diff', 'test0', 'test1a', '--json-lines'), True)
 
     def test_sort_option(self):
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
@@ -4312,7 +4312,7 @@ class DiffArchiverTestCase(ArchiverTestCaseBase):
         self.create_regular_file('d_file_added', size=256)
         self.cmd(f'--repo={self.repository_location}', 'create', 'test1', 'input')
 
-        output = self.cmd(f'--repo={self.repository_location}', 'diff', '--name=test0', '--name2=test1',
+        output = self.cmd(f'--repo={self.repository_location}', 'diff', 'test0', 'test1',
                           '--sort')
         expected = [
             'a_file_removed',

From 1ed7e5b2921674aaadbc408afc5246bc537b6ce4 Mon Sep 17 00:00:00 2001
From: Thomas Waldmann <tw@waldmann-edv.de>
Date: Mon, 20 Jun 2022 19:40:06 +0200
Subject: [PATCH 060/160] borg dump-archive NAME / dump-archive-items NAME

---
 src/borg/archiver.py           | 4 ++--
 src/borg/testsuite/archiver.py | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/borg/archiver.py b/src/borg/archiver.py
index b3bd9de68..dd9f0e20d 100644
--- a/src/borg/archiver.py
+++ b/src/borg/archiver.py
@@ -3952,7 +3952,7 @@ class Archiver:
                                           formatter_class=argparse.RawDescriptionHelpFormatter,
                                           help='dump archive items (metadata) (debug)')
         subparser.set_defaults(func=self.do_debug_dump_archive_items)
-        subparser.add_argument('--name', dest='name', metavar='NAME', type=NameSpec,
+        subparser.add_argument('name', metavar='NAME', type=NameSpec,
                                help='specify the archive name')
 
         debug_dump_archive_epilog = process_epilog("""
@@ -3964,7 +3964,7 @@ class Archiver:
                                           formatter_class=argparse.RawDescriptionHelpFormatter,
                                           help='dump decoded archive metadata (debug)')
         subparser.set_defaults(func=self.do_debug_dump_archive)
-        subparser.add_argument('--name', dest='name', metavar='NAME', type=NameSpec,
+        subparser.add_argument('name', metavar='NAME', type=NameSpec,
                                help='specify the archive name')
         subparser.add_argument('path', metavar='PATH', type=str,
                                help='file to dump data into')
diff --git a/src/borg/testsuite/archiver.py b/src/borg/testsuite/archiver.py
index f31813264..5512d0bfb 100644
--- a/src/borg/testsuite/archiver.py
+++ b/src/borg/testsuite/archiver.py
@@ -2804,7 +2804,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
         self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
         with changedir('output'):
-            output = self.cmd(f'--repo={self.repository_location}', 'debug', 'dump-archive-items', '--name=test')
+            output = self.cmd(f'--repo={self.repository_location}', 'debug', 'dump-archive-items', 'test')
         output_dir = sorted(os.listdir('output'))
         assert len(output_dir) > 0 and output_dir[0].startswith('000000_')
         assert 'Done.' in output
@@ -3283,7 +3283,7 @@ id: 2 / e29442 3506da 4e1ea7 / 25f62a 5a3d41 - 02
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
         self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
         dump_file = self.output_path + '/dump'
-        output = self.cmd(f'--repo={self.repository_location}', 'debug', 'dump-archive', '--name=test', dump_file)
+        output = self.cmd(f'--repo={self.repository_location}', 'debug', 'dump-archive', 'test', dump_file)
         assert output == ""
         with open(dump_file) as f:
             result = json.load(f)

From e6a8984c999102ef29221b2949435c215c1eacf4 Mon Sep 17 00:00:00 2001
From: Thomas Waldmann <tw@waldmann-edv.de>
Date: Mon, 20 Jun 2022 19:43:13 +0200
Subject: [PATCH 061/160] borg (import|export)-tar NAME ...

---
 src/borg/archiver.py           |  6 +++---
 src/borg/testsuite/archiver.py | 28 ++++++++++++++--------------
 2 files changed, 17 insertions(+), 17 deletions(-)

diff --git a/src/borg/archiver.py b/src/borg/archiver.py
index dd9f0e20d..fd6356268 100644
--- a/src/borg/archiver.py
+++ b/src/borg/archiver.py
@@ -4266,8 +4266,6 @@ class Archiver:
                                           formatter_class=argparse.RawDescriptionHelpFormatter,
                                           help='create tarball from archive')
         subparser.set_defaults(func=self.do_export_tar)
-        subparser.add_argument('--name', dest='name', metavar='NAME', type=NameSpec,
-                               help='specify the archive name')
         subparser.add_argument('--tar-filter', dest='tar_filter', default='auto',
                                help='filter program to pipe data through')
         subparser.add_argument('--list', dest='output_list', action='store_true',
@@ -4275,6 +4273,8 @@ class Archiver:
         subparser.add_argument('--tar-format', metavar='FMT', dest='tar_format', default='GNU',
                                choices=('BORG', 'PAX', 'GNU'),
                                help='select tar format: BORG, PAX or GNU')
+        subparser.add_argument('name', metavar='NAME', type=NameSpec,
+                               help='specify the archive name')
         subparser.add_argument('tarfile', metavar='FILE',
                                help='output tar file. "-" to write to stdout instead.')
         subparser.add_argument('paths', metavar='PATH', nargs='*', type=str,
@@ -5214,7 +5214,7 @@ class Archiver:
                                    help='select compression algorithm, see the output of the '
                                         '"borg help compression" command for details.')
 
-        subparser.add_argument('--name', dest='name', metavar='NAME', type=NameSpec,
+        subparser.add_argument('name', metavar='NAME', type=NameSpec,
                                help='specify the archive name')
         subparser.add_argument('tarfile', metavar='TARFILE',
                                help='input tar file. "-" to read from stdin instead.')
diff --git a/src/borg/testsuite/archiver.py b/src/borg/testsuite/archiver.py
index 5512d0bfb..71fb0a064 100644
--- a/src/borg/testsuite/archiver.py
+++ b/src/borg/testsuite/archiver.py
@@ -1719,14 +1719,14 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         with self.read_only(self.repository_path):
             # verify that command normally doesn't work with read-only repo
             if self.FORK_DEFAULT:
-                self.cmd(f'--repo={self.repository_location}', 'export-tar', '--name=test', 'test.tar', exit_code=EXIT_ERROR)
+                self.cmd(f'--repo={self.repository_location}', 'export-tar', 'test', 'test.tar', exit_code=EXIT_ERROR)
             else:
                 with pytest.raises((LockFailed, RemoteRepository.RPCError)) as excinfo:
-                    self.cmd(f'--repo={self.repository_location}', 'export-tar', '--name=test', 'test.tar')
+                    self.cmd(f'--repo={self.repository_location}', 'export-tar', 'test', 'test.tar')
                 if isinstance(excinfo.value, RemoteRepository.RPCError):
                     assert excinfo.value.exception_class == 'LockFailed'
             # verify that command works with read-only repo when using --bypass-lock
-            self.cmd(f'--repo={self.repository_location}', 'export-tar', '--name=test', 'test.tar', '--bypass-lock')
+            self.cmd(f'--repo={self.repository_location}', 'export-tar', 'test', 'test.tar', '--bypass-lock')
 
     def test_readonly_extract(self):
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
@@ -3364,7 +3364,7 @@ id: 2 / e29442 3506da 4e1ea7 / 25f62a 5a3d41 - 02
         os.unlink('input/flagfile')
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
         self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
-        self.cmd(f'--repo={self.repository_location}', 'export-tar', '--name=test', 'simple.tar', '--progress', '--tar-format=GNU')
+        self.cmd(f'--repo={self.repository_location}', 'export-tar', 'test', 'simple.tar', '--progress', '--tar-format=GNU')
         with changedir('output'):
             # This probably assumes GNU tar. Note -p switch to extract permissions regardless of umask.
             subprocess.check_call(['tar', 'xpf', '../simple.tar', '--warning=no-timestamp'])
@@ -3379,7 +3379,7 @@ id: 2 / e29442 3506da 4e1ea7 / 25f62a 5a3d41 - 02
         os.unlink('input/flagfile')
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
         self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
-        list = self.cmd(f'--repo={self.repository_location}', 'export-tar', '--name=test', 'simple.tar.gz',
+        list = self.cmd(f'--repo={self.repository_location}', 'export-tar', 'test', 'simple.tar.gz',
                         '--list', '--tar-format=GNU')
         assert 'input/file1\n' in list
         assert 'input/dir2\n' in list
@@ -3395,7 +3395,7 @@ id: 2 / e29442 3506da 4e1ea7 / 25f62a 5a3d41 - 02
         os.unlink('input/flagfile')
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
         self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
-        list = self.cmd(f'--repo={self.repository_location}', 'export-tar', '--name=test', 'simple.tar',
+        list = self.cmd(f'--repo={self.repository_location}', 'export-tar', 'test', 'simple.tar',
                         '--strip-components=1', '--list', '--tar-format=GNU')
         # --list's path are those before processing with --strip-components
         assert 'input/file1\n' in list
@@ -3408,7 +3408,7 @@ id: 2 / e29442 3506da 4e1ea7 / 25f62a 5a3d41 - 02
     @requires_gnutar
     def test_export_tar_strip_components_links(self):
         self._extract_hardlinks_setup()
-        self.cmd(f'--repo={self.repository_location}', 'export-tar', '--name=test', 'output.tar',
+        self.cmd(f'--repo={self.repository_location}', 'export-tar', 'test', 'output.tar',
                  '--strip-components=2', '--tar-format=GNU')
         with changedir('output'):
             subprocess.check_call(['tar', 'xpf', '../output.tar', '--warning=no-timestamp'])
@@ -3421,7 +3421,7 @@ id: 2 / e29442 3506da 4e1ea7 / 25f62a 5a3d41 - 02
     @requires_gnutar
     def test_extract_hardlinks_tar(self):
         self._extract_hardlinks_setup()
-        self.cmd(f'--repo={self.repository_location}', 'export-tar', '--name=test', 'output.tar', 'input/dir1', '--tar-format=GNU')
+        self.cmd(f'--repo={self.repository_location}', 'export-tar', 'test', 'output.tar', 'input/dir1', '--tar-format=GNU')
         with changedir('output'):
             subprocess.check_call(['tar', 'xpf', '../output.tar', '--warning=no-timestamp'])
             assert os.stat('input/dir1/hardlink').st_nlink == 2
@@ -3434,8 +3434,8 @@ id: 2 / e29442 3506da 4e1ea7 / 25f62a 5a3d41 - 02
         os.unlink('input/flagfile')
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=none')
         self.cmd(f'--repo={self.repository_location}', 'create', 'src', 'input')
-        self.cmd(f'--repo={self.repository_location}', 'export-tar', '--name=src', 'simple.tar', f'--tar-format={tar_format}')
-        self.cmd(f'--repo={self.repository_location}', 'import-tar', '--name=dst', 'simple.tar')
+        self.cmd(f'--repo={self.repository_location}', 'export-tar', 'src', 'simple.tar', f'--tar-format={tar_format}')
+        self.cmd(f'--repo={self.repository_location}', 'import-tar', 'dst', 'simple.tar')
         with changedir(self.output_path):
             self.cmd(f'--repo={self.repository_location}', 'extract', 'dst')
         self.assert_dirs_equal('input', 'output/input', ignore_ns=True, ignore_xattrs=True)
@@ -3448,8 +3448,8 @@ id: 2 / e29442 3506da 4e1ea7 / 25f62a 5a3d41 - 02
         os.unlink('input/flagfile')
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=none')
         self.cmd(f'--repo={self.repository_location}', 'create', 'src', 'input')
-        self.cmd(f'--repo={self.repository_location}', 'export-tar', '--name=src', 'simple.tgz', f'--tar-format={tar_format}')
-        self.cmd(f'--repo={self.repository_location}', 'import-tar', '--name=dst', 'simple.tgz')
+        self.cmd(f'--repo={self.repository_location}', 'export-tar', 'src', 'simple.tgz', f'--tar-format={tar_format}')
+        self.cmd(f'--repo={self.repository_location}', 'import-tar', 'dst', 'simple.tgz')
         with changedir(self.output_path):
             self.cmd(f'--repo={self.repository_location}', 'extract', 'dst')
         self.assert_dirs_equal('input', 'output/input', ignore_ns=True, ignore_xattrs=True)
@@ -3458,8 +3458,8 @@ id: 2 / e29442 3506da 4e1ea7 / 25f62a 5a3d41 - 02
         self.create_test_files()
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=none')
         self.cmd(f'--repo={self.repository_location}', 'create', 'src', 'input')
-        self.cmd(f'--repo={self.repository_location}', 'export-tar', '--name=src', 'simple.tar', '--tar-format=BORG')
-        self.cmd(f'--repo={self.repository_location}', 'import-tar', '--name=dst', 'simple.tar')
+        self.cmd(f'--repo={self.repository_location}', 'export-tar', 'src', 'simple.tar', '--tar-format=BORG')
+        self.cmd(f'--repo={self.repository_location}', 'import-tar', 'dst', 'simple.tar')
         with changedir(self.output_path):
             self.cmd(f'--repo={self.repository_location}', 'extract', 'dst')
         self.assert_dirs_equal('input', 'output/input')

From 6addafd784ddfaddf4adbbce29a069c37d9d5cd7 Mon Sep 17 00:00:00 2001
From: Thomas Waldmann <tw@waldmann-edv.de>
Date: Mon, 20 Jun 2022 20:11:26 +0200
Subject: [PATCH 062/160] borg mount -a ARCHIVE_GLOB mountpoint ...

---
 src/borg/archiver.py           |  2 --
 src/borg/fuse.py               | 26 ++++++++++---------------
 src/borg/testsuite/archiver.py | 35 +++++++++++++++++-----------------
 3 files changed, 27 insertions(+), 36 deletions(-)

diff --git a/src/borg/archiver.py b/src/borg/archiver.py
index fd6356268..c463f1809 100644
--- a/src/borg/archiver.py
+++ b/src/borg/archiver.py
@@ -3264,8 +3264,6 @@ class Archiver:
 
         def define_borg_mount(parser):
             parser.set_defaults(func=self.do_mount)
-            parser.add_argument('--name', dest='name', metavar='NAME', type=NameSpec,
-                                help='specify the archive name')
             parser.add_argument('--consider-checkpoints', action='store_true', dest='consider_checkpoints',
                                 help='Show checkpoint archives in the repository contents list (default: hidden).')
             parser.add_argument('mountpoint', metavar='MOUNTPOINT', type=str,
diff --git a/src/borg/fuse.py b/src/borg/fuse.py
index 5203a2959..b6349da7d 100644
--- a/src/borg/fuse.py
+++ b/src/borg/fuse.py
@@ -35,7 +35,7 @@ from .crypto.low_level import blake2b_128
 from .archiver import Archiver
 from .archive import Archive, get_item_uid_gid
 from .hashindex import FuseVersionsIndex
-from .helpers import daemonize, daemonizing, signal_handler, format_file_size, Error
+from .helpers import daemonize, daemonizing, signal_handler, format_file_size
 from .helpers import HardLinkManager
 from .helpers import msgpack
 from .item import Item
@@ -272,22 +272,16 @@ class FuseBackend:
 
     def _create_filesystem(self):
         self._create_dir(parent=1)  # first call, create root dir (inode == 1)
-        if self._args.name:
+        self.versions_index = FuseVersionsIndex()
+        for archive in self._manifest.archives.list_considering(self._args):
             if self.versions:
-                raise Error("for versions view, do not specify a single archive, "
-                            "but always give the repository as location.")
-            self._process_archive(self._args.name)
-        else:
-            self.versions_index = FuseVersionsIndex()
-            for archive in self._manifest.archives.list_considering(self._args):
-                if self.versions:
-                    # process archives immediately
-                    self._process_archive(archive.name)
-                else:
-                    # lazily load archives, create archive placeholder inode
-                    archive_inode = self._create_dir(parent=1, mtime=int(archive.ts.timestamp() * 1e9))
-                    self.contents[1][os.fsencode(archive.name)] = archive_inode
-                    self.pending_archives[archive_inode] = archive.name
+                # process archives immediately
+                self._process_archive(archive.name)
+            else:
+                # lazily load archives, create archive placeholder inode
+                archive_inode = self._create_dir(parent=1, mtime=int(archive.ts.timestamp() * 1e9))
+                self.contents[1][os.fsencode(archive.name)] = archive_inode
+                self.pending_archives[archive_inode] = archive.name
 
     def get_item(self, inode):
         item = self._inode_cache.get(inode)
diff --git a/src/borg/testsuite/archiver.py b/src/borg/testsuite/archiver.py
index 71fb0a064..a73580c1c 100644
--- a/src/borg/testsuite/archiver.py
+++ b/src/borg/testsuite/archiver.py
@@ -847,22 +847,22 @@ class ArchiverTestCase(ArchiverTestCaseBase):
             ignore_perms = ['-o', 'ignore_permissions,defer_permissions']
         else:
             ignore_perms = ['-o', 'ignore_permissions']
-        with self.fuse_mount(self.repository_location, mountpoint, '--name=test', '--strip-components=2', *ignore_perms), \
-             changedir(mountpoint):
+        with self.fuse_mount(self.repository_location, mountpoint, '-a', 'test', '--strip-components=2', *ignore_perms), \
+             changedir(os.path.join(mountpoint, 'test')):
             assert os.stat('hardlink').st_nlink == 2
             assert os.stat('subdir/hardlink').st_nlink == 2
             assert open('subdir/hardlink', 'rb').read() == b'123456'
             assert os.stat('aaaa').st_nlink == 2
             assert os.stat('source2').st_nlink == 2
-        with self.fuse_mount(self.repository_location, mountpoint, 'input/dir1', '--name=test', *ignore_perms), \
-             changedir(mountpoint):
+        with self.fuse_mount(self.repository_location, mountpoint, 'input/dir1', '-a', 'test', *ignore_perms), \
+             changedir(os.path.join(mountpoint, 'test')):
             assert os.stat('input/dir1/hardlink').st_nlink == 2
             assert os.stat('input/dir1/subdir/hardlink').st_nlink == 2
             assert open('input/dir1/subdir/hardlink', 'rb').read() == b'123456'
             assert os.stat('input/dir1/aaaa').st_nlink == 2
             assert os.stat('input/dir1/source2').st_nlink == 2
-        with self.fuse_mount(self.repository_location, mountpoint, '--name=test', *ignore_perms), \
-             changedir(mountpoint):
+        with self.fuse_mount(self.repository_location, mountpoint, '-a', 'test', *ignore_perms), \
+             changedir(os.path.join(mountpoint, 'test')):
             assert os.stat('input/source').st_nlink == 4
             assert os.stat('input/abba').st_nlink == 4
             assert os.stat('input/dir1/hardlink').st_nlink == 4
@@ -2527,13 +2527,12 @@ class ArchiverTestCase(ArchiverTestCaseBase):
                                    ignore_flags=True, ignore_xattrs=True)
             self.assert_dirs_equal(self.input_path, os.path.join(mountpoint, 'archive2', 'input'),
                                    ignore_flags=True, ignore_xattrs=True)
-        # mount only 1 archive, its contents shall show up directly in mountpoint:
-        with self.fuse_mount(self.repository_location, mountpoint, '--name=archive'):
-            self.assert_dirs_equal(self.input_path, os.path.join(mountpoint, 'input'),
+        with self.fuse_mount(self.repository_location, mountpoint, '-a', 'archive'):
+            self.assert_dirs_equal(self.input_path, os.path.join(mountpoint, 'archive', 'input'),
                                    ignore_flags=True, ignore_xattrs=True)
             # regular file
             in_fn = 'input/file1'
-            out_fn = os.path.join(mountpoint, 'input', 'file1')
+            out_fn = os.path.join(mountpoint, 'archive', 'input', 'file1')
             # stat
             sti1 = os.stat(in_fn)
             sto1 = os.stat(out_fn)
@@ -2554,7 +2553,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
             # hardlink (to 'input/file1')
             if are_hardlinks_supported():
                 in_fn = 'input/hardlink'
-                out_fn = os.path.join(mountpoint, 'input', 'hardlink')
+                out_fn = os.path.join(mountpoint, 'archive', 'input', 'hardlink')
                 sti2 = os.stat(in_fn)
                 sto2 = os.stat(out_fn)
                 assert sti2.st_nlink == sto2.st_nlink == 2
@@ -2562,7 +2561,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
             # symlink
             if are_symlinks_supported():
                 in_fn = 'input/link1'
-                out_fn = os.path.join(mountpoint, 'input', 'link1')
+                out_fn = os.path.join(mountpoint, 'archive', 'input', 'link1')
                 sti = os.stat(in_fn, follow_symlinks=False)
                 sto = os.stat(out_fn, follow_symlinks=False)
                 assert sti.st_size == len('somewhere')
@@ -2572,13 +2571,13 @@ class ArchiverTestCase(ArchiverTestCaseBase):
                 assert os.readlink(in_fn) == os.readlink(out_fn)
             # FIFO
             if are_fifos_supported():
-                out_fn = os.path.join(mountpoint, 'input', 'fifo1')
+                out_fn = os.path.join(mountpoint, 'archive', 'input', 'fifo1')
                 sto = os.stat(out_fn)
                 assert stat.S_ISFIFO(sto.st_mode)
             # list/read xattrs
             try:
                 in_fn = 'input/fusexattr'
-                out_fn = os.fsencode(os.path.join(mountpoint, 'input', 'fusexattr'))
+                out_fn = os.fsencode(os.path.join(mountpoint, 'archive', 'input', 'fusexattr'))
                 if not xattr.XATTR_FAKEROOT and xattr.is_enabled(self.input_path):
                     assert sorted(no_selinux(xattr.listxattr(out_fn))) == [b'user.empty', b'user.foo', ]
                     assert xattr.getxattr(out_fn, b'user.foo') == b'bar'
@@ -2648,12 +2647,12 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self.cmd(f'--repo={self.repository_location}', 'check', '--repair', exit_code=0)
 
         mountpoint = os.path.join(self.tmpdir, 'mountpoint')
-        with self.fuse_mount(self.repository_location, mountpoint, '--name=archive'):
+        with self.fuse_mount(self.repository_location, mountpoint, '-a', 'archive'):
             with pytest.raises(OSError) as excinfo:
-                open(os.path.join(mountpoint, path))
+                open(os.path.join(mountpoint, 'archive', path))
             assert excinfo.value.errno == errno.EIO
-        with self.fuse_mount(self.repository_location, mountpoint, '--name=archive', '-o', 'allow_damaged_files'):
-            open(os.path.join(mountpoint, path)).close()
+        with self.fuse_mount(self.repository_location, mountpoint, '-a', 'archive', '-o', 'allow_damaged_files'):
+            open(os.path.join(mountpoint, 'archive', path)).close()
 
     @unittest.skipUnless(llfuse, 'llfuse not installed')
     def test_fuse_mount_options(self):

From 1bf8f71e69093c93347b096d3f1a981a4b1e418e Mon Sep 17 00:00:00 2001
From: Thomas Waldmann <tw@waldmann-edv.de>
Date: Tue, 21 Jun 2022 00:35:05 +0200
Subject: [PATCH 063/160] borg list ARCHIVE, borg rlist

---
 src/borg/archiver.py           | 110 +++++++++++++----------
 src/borg/testsuite/archiver.py | 155 ++++++++++++++++-----------------
 2 files changed, 137 insertions(+), 128 deletions(-)

diff --git a/src/borg/archiver.py b/src/borg/archiver.py
index c463f1809..37d7464b8 100644
--- a/src/borg/archiver.py
+++ b/src/borg/archiver.py
@@ -1700,19 +1700,7 @@ class Archiver:
 
     @with_repository(compatibility=(Manifest.Operation.READ,))
     def do_list(self, args, repository, manifest, key):
-        """List archive or repository contents"""
-        if args.name:
-            if args.json:
-                self.print_error('The --json option is only valid for listing archives, not archive contents.')
-                return self.exit_code
-            return self._list_archive(args, repository, manifest, key)
-        else:
-            if args.json_lines:
-                self.print_error('The --json-lines option is only valid for listing archive contents, not archives.')
-                return self.exit_code
-            return self._list_repository(args, repository, manifest, key)
-
-    def _list_archive(self, args, repository, manifest, key):
+        """List archive contents"""
         matcher = self.build_matcher(args.patterns, args.paths)
         if args.format is not None:
             format = args.format
@@ -1738,7 +1726,9 @@ class Archiver:
 
         return self.exit_code
 
-    def _list_repository(self, args, repository, manifest, key):
+    @with_repository(compatibility=(Manifest.Operation.READ,))
+    def do_rlist(self, args, repository, manifest, key):
+        """List the archives contained in a repository"""
         if args.format is not None:
             format = args.format
         elif args.short:
@@ -4686,7 +4676,7 @@ class Archiver:
 
         # borg list
         list_epilog = process_epilog("""
-        This command lists the contents of a repository or an archive.
+        This command lists the contents of an archive.
 
         For more help on include/exclude patterns, see the :ref:`borg_patterns` command output.
 
@@ -4701,35 +4691,20 @@ class Archiver:
         Examples:
         ::
 
-            $ borg list --format '{archive}{NL}' /path/to/repo
-            ArchiveFoo
-            ArchiveBar
-            ...
-
-            # {VAR:NUMBER} - pad to NUMBER columns.
-            # Strings are left-aligned, numbers are right-aligned.
-            # Note: time columns except ``isomtime``, ``isoctime`` and ``isoatime`` cannot be padded.
-            $ borg list --format '{archive:36} {time} [{id}]{NL}' /path/to/repo
-            ArchiveFoo                           Thu, 2021-12-09 10:22:28 [0b8e9a312bef3f2f6e2d0fc110c196827786c15eba0188738e81697a7fa3b274]
-            $ borg list --format '{mode} {user:6} {group:6} {size:8} {mtime} {path}{extra}{NL}' /path/to/repo::ArchiveFoo
+            $ borg list --format '{mode} {user:6} {group:6} {size:8} {mtime} {path}{extra}{NL}' ArchiveFoo
             -rw-rw-r-- user   user       1024 Thu, 2021-12-09 10:22:17 file-foo
             ...
 
             # {VAR:<NUMBER} - pad to NUMBER columns left-aligned.
             # {VAR:>NUMBER} - pad to NUMBER columns right-aligned.
-            $ borg list --format '{mode} {user:>6} {group:>6} {size:<8} {mtime} {path}{extra}{NL}' /path/to/repo::ArchiveFoo
+            $ borg list --format '{mode} {user:>6} {group:>6} {size:<8} {mtime} {path}{extra}{NL}' ArchiveFoo
             -rw-rw-r--   user   user 1024     Thu, 2021-12-09 10:22:17 file-foo
             ...
 
         The following keys are always available:
 
-
         """) + BaseFormatter.keys_help() + textwrap.dedent("""
 
-        Keys available only when listing archives in a repository:
-
-        """) + ArchiveFormatter.keys_help() + textwrap.dedent("""
-
         Keys available only when listing files in an archive:
 
         """) + ItemFormatter.keys_help()
@@ -4737,35 +4712,74 @@ class Archiver:
                                           description=self.do_list.__doc__,
                                           epilog=list_epilog,
                                           formatter_class=argparse.RawDescriptionHelpFormatter,
-                                          help='list archive or repository contents')
+                                          help='list archive contents')
         subparser.set_defaults(func=self.do_list)
-        subparser.add_argument('--consider-checkpoints', action='store_true', dest='consider_checkpoints',
-                help='Show checkpoint archives in the repository contents list (default: hidden).')
         subparser.add_argument('--short', dest='short', action='store_true',
                                help='only print file/directory names, nothing else')
         subparser.add_argument('--format', metavar='FORMAT', dest='format',
-                               help='specify format for file or archive listing '
-                                    '(default for files: "{mode} {user:6} {group:6} {size:8} {mtime} {path}{extra}{NL}"; '
-                                    'for archives: "{archive:<36} {time} [{id}]{NL}")')
-        subparser.add_argument('--json', action='store_true',
-                               help='Only valid for listing repository contents. Format output as JSON. '
-                                    'The form of ``--format`` is ignored, '
-                                    'but keys used in it are added to the JSON output. '
-                                    'Some keys are always present. Note: JSON can only represent text. '
-                                    'A "barchive" key is therefore not available.')
+                               help='specify format for file listing '
+                                    '(default: "{mode} {user:6} {group:6} {size:8} {mtime} {path}{extra}{NL}")')
         subparser.add_argument('--json-lines', action='store_true',
-                               help='Only valid for listing archive contents. Format output as JSON Lines. '
+                               help='Format output as JSON Lines. '
                                     'The form of ``--format`` is ignored, '
                                     'but keys used in it are added to the JSON output. '
                                     'Some keys are always present. Note: JSON can only represent text. '
                                     'A "bpath" key is therefore not available.')
-        subparser.add_argument('--name', dest='name', metavar='NAME', type=NameSpec,
+        subparser.add_argument('name', metavar='NAME', type=NameSpec,
                                help='specify the archive name')
         subparser.add_argument('paths', metavar='PATH', nargs='*', type=str,
                                help='paths to list; patterns are supported')
-        define_archive_filters_group(subparser)
         define_exclusion_group(subparser)
 
+        # borg rlist
+        rlist_epilog = process_epilog("""
+        This command lists the archives contained in a repository.
+        .. man NOTES
+        The FORMAT specifier syntax
+        +++++++++++++++++++++++++++
+        The ``--format`` option uses python's `format string syntax
+        <https://docs.python.org/3.9/library/string.html#formatstrings>`_.
+        Examples:
+        ::
+            $ borg rlist --format '{archive}{NL}'
+            ArchiveFoo
+            ArchiveBar
+            ...
+
+            # {VAR:NUMBER} - pad to NUMBER columns.
+            # Strings are left-aligned, numbers are right-aligned.
+            # Note: time columns except ``isomtime``, ``isoctime`` and ``isoatime`` cannot be padded.
+            $ borg rlist --format '{archive:36} {time} [{id}]{NL}' /path/to/repo
+            ArchiveFoo                           Thu, 2021-12-09 10:22:28 [0b8e9a312bef3f2f6e2d0fc110c196827786c15eba0188738e81697a7fa3b274]
+            ...
+
+        The following keys are always available:
+
+        """) + BaseFormatter.keys_help() + textwrap.dedent("""
+        Keys available only when listing archives in a repository:
+
+        """) + ArchiveFormatter.keys_help()
+        subparser = subparsers.add_parser('rlist', parents=[common_parser], add_help=False,
+                                          description=self.do_rlist.__doc__,
+                                          epilog=rlist_epilog,
+                                          formatter_class=argparse.RawDescriptionHelpFormatter,
+                                          help='list repository contents')
+        subparser.set_defaults(func=self.do_rlist)
+        subparser.add_argument('--consider-checkpoints', action='store_true', dest='consider_checkpoints',
+                               help='Show checkpoint archives in the repository contents list (default: hidden).')
+        subparser.add_argument('--short', dest='short', action='store_true',
+                               help='only print the archive names, nothing else')
+        subparser.add_argument('--format', metavar='FORMAT', dest='format',
+                               help='specify format for archive listing '
+                                    '(default: "{archive:<36} {time} [{id}]{NL}")')
+        subparser.add_argument('--json', action='store_true',
+                               help='Format output as JSON. '
+                                    'The form of ``--format`` is ignored, '
+                                    'but keys used in it are added to the JSON output. '
+                                    'Some keys are always present. Note: JSON can only represent text. '
+                                    'A "barchive" key is therefore not available.')
+        define_archive_filters_group(subparser)
+
         subparser = subparsers.add_parser('mount', parents=[common_parser], add_help=False,
                                         description=self.do_mount.__doc__,
                                         epilog=mount_epilog,
@@ -5280,7 +5294,7 @@ class Archiver:
         if not getattr(args, 'lock', True):  # Option --bypass-lock sets args.lock = False
             bypass_allowed = {self.do_check, self.do_config, self.do_diff,
                               self.do_export_tar, self.do_extract, self.do_info,
-                              self.do_list, self.do_mount, self.do_umount}
+                              self.do_list, self.do_rlist, self.do_mount, self.do_umount}
             if func not in bypass_allowed:
                 raise Error('Not allowed to bypass locking mechanism for chosen command')
         if getattr(args, 'timestamp', None):
diff --git a/src/borg/testsuite/archiver.py b/src/borg/testsuite/archiver.py
index a73580c1c..ce97c3fe7 100644
--- a/src/borg/testsuite/archiver.py
+++ b/src/borg/testsuite/archiver.py
@@ -231,9 +231,9 @@ def test_disk_full(cmd):
                 # now some error happened, likely we are out of disk space.
                 # free some space so we can expect borg to be able to work normally:
                 shutil.rmtree(reserve, ignore_errors=True)
-            rc, out = cmd(f'--repo={repo}', 'list')
+            rc, out = cmd(f'--repo={repo}', 'rlist')
             if rc != EXIT_SUCCESS:
-                print('list', rc, out)
+                print('rlist', rc, out)
             rc, out = cmd(f'--repo={repo}', 'check', '--repair')
             if rc != EXIT_SUCCESS:
                 print('check', rc, out)
@@ -400,7 +400,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self.assert_in('This archive: ', output)
         with changedir('output'):
             self.cmd(f'--repo={self.repository_location}', 'extract', 'test')
-        list_output = self.cmd(f'--repo={self.repository_location}', 'list', '--short')
+        list_output = self.cmd(f'--repo={self.repository_location}', 'rlist', '--short')
         self.assert_in('test', list_output)
         self.assert_in('test.2', list_output)
         expected = [
@@ -427,7 +427,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
             # remove the file we did not backup, so input and output become equal
             expected.remove('input/flagfile')  # this file is UF_NODUMP
             os.remove(os.path.join('input', 'flagfile'))
-        list_output = self.cmd(f'--repo={self.repository_location}', 'list', '--name=test', '--short')
+        list_output = self.cmd(f'--repo={self.repository_location}', 'list', 'test', '--short')
         for name in expected:
             self.assert_in(name, list_output)
         self.assert_dirs_equal('input', 'output/input')
@@ -465,7 +465,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=none')
         self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input', 'input')  # give input twice!
         # test if created archive has 'input' contents twice:
-        archive_list = self.cmd(f'--repo={self.repository_location}', 'list', '--name=test', '--json-lines')
+        archive_list = self.cmd(f'--repo={self.repository_location}', 'list', 'test', '--json-lines')
         paths = [json.loads(line)['path'] for line in archive_list.split('\n') if line]
         # we have all fs items exactly once!
         assert sorted(paths) == ['input', 'input/a', 'input/a/hardlink', 'input/b', 'input/b/hardlink']
@@ -1096,7 +1096,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
         input_data = b'\x00foo\n\nbar\n   \n'
         self.cmd(f'--repo={self.repository_location}', 'create', 'test', '-', input=input_data)
-        item = json.loads(self.cmd(f'--repo={self.repository_location}', 'list', '--name=test', '--json-lines'))
+        item = json.loads(self.cmd(f'--repo={self.repository_location}', 'list', 'test', '--json-lines'))
         assert item['uid'] == 0
         assert item['gid'] == 0
         assert item['size'] == len(input_data)
@@ -1110,7 +1110,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         name = 'a/b/c'
         self.cmd(f'--repo={self.repository_location}', 'create', '--stdin-name', name, '--content-from-command',
                  'test', '--', 'echo', input_data)
-        item = json.loads(self.cmd(f'--repo={self.repository_location}', 'list', '--name=test', '--json-lines'))
+        item = json.loads(self.cmd(f'--repo={self.repository_location}', 'list', 'test', '--json-lines'))
         assert item['uid'] == 0
         assert item['gid'] == 0
         assert item['size'] == len(input_data) + 1  # `echo` adds newline
@@ -1123,7 +1123,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         output = self.cmd(f'--repo={self.repository_location}', 'create', '--content-from-command', 'test',
                           '--', 'sh', '-c', 'exit 73;', exit_code=2)
         assert output.endswith("Command 'sh' exited with status 73\n")
-        archive_list = json.loads(self.cmd(f'--repo={self.repository_location}', 'list', '--json'))
+        archive_list = json.loads(self.cmd(f'--repo={self.repository_location}', 'rlist', '--json'))
         assert archive_list['archives'] == []
 
     def test_create_content_from_command_missing_command(self):
@@ -1141,7 +1141,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         input_data = b'input/file1\0input/dir1\0input/file4'
         self.cmd(f'--repo={self.repository_location}', 'create', 'test',
                  '--paths-from-stdin', '--paths-delimiter', '\\0', input=input_data)
-        archive_list = self.cmd(f'--repo={self.repository_location}', 'list', '--name=test', '--json-lines')
+        archive_list = self.cmd(f'--repo={self.repository_location}', 'list', 'test', '--json-lines')
         paths = [json.loads(line)['path'] for line in archive_list.split('\n') if line]
         assert paths == ['input/file1', 'input/dir1', 'input/file4']
 
@@ -1155,7 +1155,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         input_data = 'input/file1\ninput/file2\ninput/file3'
         self.cmd(f'--repo={self.repository_location}', 'create', '--paths-from-command', 'test',
                  '--', 'echo', input_data)
-        archive_list = self.cmd(f'--repo={self.repository_location}', 'list', '--name=test', '--json-lines')
+        archive_list = self.cmd(f'--repo={self.repository_location}', 'list', 'test', '--json-lines')
         paths = [json.loads(line)['path'] for line in archive_list.split('\n') if line]
         assert paths == ['input/file1', 'input/file2', 'input/file3']
 
@@ -1164,7 +1164,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         output = self.cmd(f'--repo={self.repository_location}', 'create', '--paths-from-command', 'test',
                           '--', 'sh', '-c', 'exit 73;', exit_code=2)
         assert output.endswith("Command 'sh' exited with status 73\n")
-        archive_list = json.loads(self.cmd(f'--repo={self.repository_location}', 'list', '--json'))
+        archive_list = json.loads(self.cmd(f'--repo={self.repository_location}', 'rlist', '--json'))
         assert archive_list['archives'] == []
 
     def test_create_paths_from_command_missing_command(self):
@@ -1264,7 +1264,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
 
         # list the archive and verify that the "intermediate" folders appear before
         # their contents
-        out = self.cmd(f'--repo={self.repository_location}', 'list', '--name=test', '--format', '{type} {path}{NL}')
+        out = self.cmd(f'--repo={self.repository_location}', 'list', 'test', '--format', '{type} {path}{NL}')
         out_list = out.splitlines()
 
         self.assert_in('d x/a', out_list)
@@ -1453,7 +1453,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         with changedir('input/dir1/dir2'):
             self.cmd(f'--repo={self.repository_location}', 'create', 'test',
                      '../../../input/dir1/../dir1/dir2/..')
-        output = self.cmd(f'--repo={self.repository_location}', 'list', '--name=test')
+        output = self.cmd(f'--repo={self.repository_location}', 'list', 'test')
         self.assert_not_in('..', output)
         self.assert_in(' input/dir1/dir2/file', output)
 
@@ -1618,7 +1618,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self.cmd(f'--repo={self.repository_location}', 'delete', '--name=test1', 'test2')
         self.cmd(f'--repo={self.repository_location}', 'extract', 'test3', '--dry-run')
         self.cmd(f'--repo={self.repository_location}', 'delete', '--name=test3')
-        assert not self.cmd(f'--repo={self.repository_location}', 'list')
+        assert not self.cmd(f'--repo={self.repository_location}', 'rlist')
 
     def test_delete_repo(self):
         self.create_regular_file('file1', size=1024 * 80)
@@ -1650,7 +1650,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         output = self.cmd(f'--repo={self.repository_location}', 'delete', '--name=test', '--force')
         self.assert_in('deleted archive was corrupted', output)
         self.cmd(f'--repo={self.repository_location}', 'check', '--repair')
-        output = self.cmd(f'--repo={self.repository_location}', 'list')
+        output = self.cmd(f'--repo={self.repository_location}', 'rlist')
         self.assert_not_in('test', output)
 
     def test_delete_double_force(self):
@@ -1664,7 +1664,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
             repository.commit(compact=False)
         self.cmd(f'--repo={self.repository_location}', 'delete', '--name=test', '--force', '--force')
         self.cmd(f'--repo={self.repository_location}', 'check', '--repair')
-        output = self.cmd(f'--repo={self.repository_location}', 'list')
+        output = self.cmd(f'--repo={self.repository_location}', 'rlist')
         self.assert_not_in('test', output)
 
     def test_corrupted_repository(self):
@@ -1764,14 +1764,14 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         with self.read_only(self.repository_path):
             # verify that command normally doesn't work with read-only repo
             if self.FORK_DEFAULT:
-                self.cmd(f'--repo={self.repository_location}', 'list', exit_code=EXIT_ERROR)
+                self.cmd(f'--repo={self.repository_location}', 'rlist', exit_code=EXIT_ERROR)
             else:
                 with pytest.raises((LockFailed, RemoteRepository.RPCError)) as excinfo:
-                    self.cmd(f'--repo={self.repository_location}', 'list')
+                    self.cmd(f'--repo={self.repository_location}', 'rlist')
                 if isinstance(excinfo.value, RemoteRepository.RPCError):
                     assert excinfo.value.exception_class == 'LockFailed'
             # verify that command works with read-only repo when using --bypass-lock
-            self.cmd(f'--repo={self.repository_location}', 'list', '--bypass-lock')
+            self.cmd(f'--repo={self.repository_location}', 'rlist', '--bypass-lock')
 
     @unittest.skipUnless(llfuse, 'llfuse not installed')
     def test_readonly_mount(self):
@@ -1847,7 +1847,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         with changedir('output'):
             self.cmd_raises_unknown_feature([f'--repo={self.repository_location}', 'extract', 'test'])
 
-        self.cmd_raises_unknown_feature([f'--repo={self.repository_location}', 'list'])
+        self.cmd_raises_unknown_feature([f'--repo={self.repository_location}', 'rlist'])
         self.cmd_raises_unknown_feature([f'--repo={self.repository_location}', 'info', '--name=test'])
 
     def test_unknown_feature_on_rename(self):
@@ -2093,7 +2093,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         os.symlink('somewhere does not exist', os.path.join(self.input_path, 'link'))
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
         self.cmd(f'--repo={self.repository_location}', 'create', '--read-special', 'test', 'input')
-        output = self.cmd(f'--repo={self.repository_location}', 'list', '--name=test')
+        output = self.cmd(f'--repo={self.repository_location}', 'list', 'test')
         assert 'input/link -> somewhere does not exist' in output
 
     # def test_cmdline_compatibility(self):
@@ -2117,14 +2117,14 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         assert re.search(r'Keeping archive \(rule: daily #1\):\s+test2', output)
         # must keep the latest checkpoint archive:
         assert re.search(r'Keeping checkpoint archive:\s+test4.checkpoint', output)
-        output = self.cmd(f'--repo={self.repository_location}', 'list', '--consider-checkpoints')
+        output = self.cmd(f'--repo={self.repository_location}', 'rlist', '--consider-checkpoints')
         self.assert_in('test1', output)
         self.assert_in('test2', output)
         self.assert_in('test3.checkpoint', output)
         self.assert_in('test3.checkpoint.1', output)
         self.assert_in('test4.checkpoint', output)
         self.cmd(f'--repo={self.repository_location}', 'prune', '--keep-daily=1')
-        output = self.cmd(f'--repo={self.repository_location}', 'list', '--consider-checkpoints')
+        output = self.cmd(f'--repo={self.repository_location}', 'rlist', '--consider-checkpoints')
         self.assert_not_in('test1', output)
         # the latest non-checkpoint archive must be still there:
         self.assert_in('test2', output)
@@ -2135,7 +2135,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         # now we supersede the latest checkpoint by a successful backup:
         self.cmd(f'--repo={self.repository_location}', 'create', 'test5', src_dir)
         self.cmd(f'--repo={self.repository_location}', 'prune', '--keep-daily=2')
-        output = self.cmd(f'--repo={self.repository_location}', 'list', '--consider-checkpoints')
+        output = self.cmd(f'--repo={self.repository_location}', 'rlist', '--consider-checkpoints')
         # all checkpoints should be gone now:
         self.assert_not_in('checkpoint', output)
         # the latest archive must be still there
@@ -2199,12 +2199,12 @@ class ArchiverTestCase(ArchiverTestCaseBase):
             assert re.search(r'Keeping archive \(rule: monthly #' + str(i) + r'\):\s+test' + ("%02d" % (8-i)), output)
         for i in range(1, 15):
             assert re.search(r'Keeping archive \(rule: daily #' + str(i) + r'\):\s+test' + ("%02d" % (22-i)), output)
-        output = self.cmd(f'--repo={self.repository_location}', 'list')
+        output = self.cmd(f'--repo={self.repository_location}', 'rlist')
         # Nothing pruned after dry run
         for i in range(1, 25):
             self.assert_in('test%02d' % i, output)
         self.cmd(f'--repo={self.repository_location}', 'prune', '--keep-daily=14', '--keep-monthly=6', '--keep-yearly=1')
-        output = self.cmd(f'--repo={self.repository_location}', 'list')
+        output = self.cmd(f'--repo={self.repository_location}', 'rlist')
         # All matching backups plus oldest kept
         for i in range(1, 22):
             self.assert_in('test%02d' % i, output)
@@ -2243,11 +2243,11 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         output = self.cmd(f'--repo={self.repository_location}', 'prune', '--list', '--dry-run', '--keep-daily=1')
         assert re.search(r'Keeping archive \(rule: daily #1\):\s+test2', output)
         assert re.search(r'Would prune:\s+test1', output)
-        output = self.cmd(f'--repo={self.repository_location}', 'list')
+        output = self.cmd(f'--repo={self.repository_location}', 'rlist')
         self.assert_in('test1', output)
         self.assert_in('test2', output)
         self.cmd(f'--repo={self.repository_location}', 'prune', '--save-space', '--keep-daily=1')
-        output = self.cmd(f'--repo={self.repository_location}', 'list')
+        output = self.cmd(f'--repo={self.repository_location}', 'rlist')
         self.assert_not_in('test1', output)
         self.assert_in('test2', output)
 
@@ -2260,13 +2260,13 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         output = self.cmd(f'--repo={self.repository_location}', 'prune', '--list', '--dry-run', '--keep-daily=1', '--prefix=foo-')
         assert re.search(r'Keeping archive \(rule: daily #1\):\s+foo-2015-08-12-20:00', output)
         assert re.search(r'Would prune:\s+foo-2015-08-12-10:00', output)
-        output = self.cmd(f'--repo={self.repository_location}', 'list')
+        output = self.cmd(f'--repo={self.repository_location}', 'rlist')
         self.assert_in('foo-2015-08-12-10:00', output)
         self.assert_in('foo-2015-08-12-20:00', output)
         self.assert_in('bar-2015-08-12-10:00', output)
         self.assert_in('bar-2015-08-12-20:00', output)
         self.cmd(f'--repo={self.repository_location}', 'prune', '--keep-daily=1', '--prefix=foo-')
-        output = self.cmd(f'--repo={self.repository_location}', 'list')
+        output = self.cmd(f'--repo={self.repository_location}', 'rlist')
         self.assert_not_in('foo-2015-08-12-10:00', output)
         self.assert_in('foo-2015-08-12-20:00', output)
         self.assert_in('bar-2015-08-12-10:00', output)
@@ -2281,13 +2281,13 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         output = self.cmd(f'--repo={self.repository_location}', 'prune', '--list', '--dry-run', '--keep-daily=1', '--glob-archives=2015-*-foo')
         assert re.search(r'Keeping archive \(rule: daily #1\):\s+2015-08-12-20:00-foo', output)
         assert re.search(r'Would prune:\s+2015-08-12-10:00-foo', output)
-        output = self.cmd(f'--repo={self.repository_location}', 'list')
+        output = self.cmd(f'--repo={self.repository_location}', 'rlist')
         self.assert_in('2015-08-12-10:00-foo', output)
         self.assert_in('2015-08-12-20:00-foo', output)
         self.assert_in('2015-08-12-10:00-bar', output)
         self.assert_in('2015-08-12-20:00-bar', output)
         self.cmd(f'--repo={self.repository_location}', 'prune', '--keep-daily=1', '--glob-archives=2015-*-foo')
-        output = self.cmd(f'--repo={self.repository_location}', 'list')
+        output = self.cmd(f'--repo={self.repository_location}', 'rlist')
         self.assert_not_in('2015-08-12-10:00-foo', output)
         self.assert_in('2015-08-12-20:00-foo', output)
         self.assert_in('2015-08-12-10:00-bar', output)
@@ -2298,7 +2298,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self.cmd(f'--repo={self.repository_location}', 'create', 'test-1', src_dir)
         self.cmd(f'--repo={self.repository_location}', 'create', 'something-else-than-test-1', src_dir)
         self.cmd(f'--repo={self.repository_location}', 'create', 'test-2', src_dir)
-        output = self.cmd(f'--repo={self.repository_location}', 'list', '--prefix=test-')
+        output = self.cmd(f'--repo={self.repository_location}', 'rlist', '--prefix=test-')
         self.assert_in('test-1', output)
         self.assert_in('test-2', output)
         self.assert_not_in('something-else', output)
@@ -2306,24 +2306,24 @@ class ArchiverTestCase(ArchiverTestCaseBase):
     def test_list_format(self):
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
         self.cmd(f'--repo={self.repository_location}', 'create', 'test', src_dir)
-        output_1 = self.cmd(f'--repo={self.repository_location}', 'list', '--name=test')
-        output_2 = self.cmd(f'--repo={self.repository_location}', 'list', '--name=test', '--format', '{mode} {user:6} {group:6} {size:8d} {mtime} {path}{extra}{NEWLINE}')
-        output_3 = self.cmd(f'--repo={self.repository_location}', 'list', '--name=test', '--format', '{mtime:%s} {path}{NL}')
+        output_1 = self.cmd(f'--repo={self.repository_location}', 'list', 'test')
+        output_2 = self.cmd(f'--repo={self.repository_location}', 'list', 'test', '--format', '{mode} {user:6} {group:6} {size:8d} {mtime} {path}{extra}{NEWLINE}')
+        output_3 = self.cmd(f'--repo={self.repository_location}', 'list', 'test', '--format', '{mtime:%s} {path}{NL}')
         self.assertEqual(output_1, output_2)
         self.assertNotEqual(output_1, output_3)
 
-    def test_list_repository_format(self):
+    def test_archives_format(self):
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
         self.cmd(f'--repo={self.repository_location}', 'create', '--comment', 'comment 1', 'test-1', src_dir)
         self.cmd(f'--repo={self.repository_location}', 'create', '--comment', 'comment 2', 'test-2', src_dir)
-        output_1 = self.cmd(f'--repo={self.repository_location}', 'list')
-        output_2 = self.cmd(f'--repo={self.repository_location}', 'list', '--format', '{archive:<36} {time} [{id}]{NL}')
+        output_1 = self.cmd(f'--repo={self.repository_location}', 'rlist')
+        output_2 = self.cmd(f'--repo={self.repository_location}', 'rlist', '--format', '{archive:<36} {time} [{id}]{NL}')
         self.assertEqual(output_1, output_2)
-        output_1 = self.cmd(f'--repo={self.repository_location}', 'list', '--short')
+        output_1 = self.cmd(f'--repo={self.repository_location}', 'rlist', '--short')
         self.assertEqual(output_1, 'test-1\ntest-2\n')
-        output_1 = self.cmd(f'--repo={self.repository_location}', 'list', '--format', '{barchive}/')
+        output_1 = self.cmd(f'--repo={self.repository_location}', 'rlist', '--format', '{barchive}/')
         self.assertEqual(output_1, 'test-1/test-2/')
-        output_3 = self.cmd(f'--repo={self.repository_location}', 'list', '--format', '{name} {comment}{NL}')
+        output_3 = self.cmd(f'--repo={self.repository_location}', 'rlist', '--format', '{name} {comment}{NL}')
         self.assert_in('test-1 comment 1\n', output_3)
         self.assert_in('test-2 comment 2\n', output_3)
 
@@ -2332,7 +2332,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self.create_regular_file('amb', contents=b'a' * 1000000)
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
         self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
-        output = self.cmd(f'--repo={self.repository_location}', 'list', '--name=test', '--format', '{sha256} {path}{NL}')
+        output = self.cmd(f'--repo={self.repository_location}', 'list', 'test', '--format', '{sha256} {path}{NL}')
         assert "cdc76e5c9914fb9281a1c7e284d73e67f1809a48a497200e046d39ccc7112cd0 input/amb" in output
         assert "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855 input/empty_file" in output
 
@@ -2342,11 +2342,11 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         # these are not really a checkpoints, but they look like some:
         self.cmd(f'--repo={self.repository_location}', 'create', 'test2.checkpoint', src_dir)
         self.cmd(f'--repo={self.repository_location}', 'create', 'test3.checkpoint.1', src_dir)
-        output = self.cmd(f'--repo={self.repository_location}', 'list')
+        output = self.cmd(f'--repo={self.repository_location}', 'rlist')
         assert "test1" in output
         assert "test2.checkpoint" not in output
         assert "test3.checkpoint.1" not in output
-        output = self.cmd(f'--repo={self.repository_location}', 'list', '--consider-checkpoints')
+        output = self.cmd(f'--repo={self.repository_location}', 'rlist', '--consider-checkpoints')
         assert "test1" in output
         assert "test2.checkpoint" in output
         assert "test3.checkpoint.1" in output
@@ -2359,7 +2359,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
             fd.write(b'baab' * 2000000)
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
         self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
-        output = self.cmd(f'--repo={self.repository_location}', 'list', '--name=test', '--format', '{num_chunks} {unique_chunks} {path}{NL}')
+        output = self.cmd(f'--repo={self.repository_location}', 'list', 'test', '--format', '{num_chunks} {unique_chunks} {path}{NL}')
         assert "0 0 input/empty_file" in output
         assert "2 2 input/two_chunks" in output
 
@@ -2367,7 +2367,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self.create_regular_file('compressible_file', size=10000)
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
         self.cmd(f'--repo={self.repository_location}', 'create', '-C', 'lz4', 'test', 'input')
-        output = self.cmd(f'--repo={self.repository_location}', 'list', '--name=test', '--format', '{size} {path}{NL}')
+        output = self.cmd(f'--repo={self.repository_location}', 'list', 'test', '--format', '{size} {path}{NL}')
         size, path = output.split("\n")[1].split(" ")
         assert int(size) == 10000
 
@@ -2375,7 +2375,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self.create_regular_file('file1', size=1024 * 80)
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
         self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
-        list_repo = json.loads(self.cmd(f'--repo={self.repository_location}', 'list', '--json'))
+        list_repo = json.loads(self.cmd(f'--repo={self.repository_location}', 'rlist', '--json'))
         repository = list_repo['repository']
         assert len(repository['id']) == 64
         assert datetime.strptime(repository['last_modified'], ISO_FORMAT)  # must not raise
@@ -2384,7 +2384,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         archive0 = list_repo['archives'][0]
         assert datetime.strptime(archive0['time'], ISO_FORMAT)  # must not raise
 
-        list_archive = self.cmd(f'--repo={self.repository_location}', 'list', '--name=test', '--json-lines')
+        list_archive = self.cmd(f'--repo={self.repository_location}', 'list', 'test', '--json-lines')
         items = [json.loads(s) for s in list_archive.splitlines()]
         assert len(items) == 2
         file1 = items[1]
@@ -2392,18 +2392,13 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         assert file1['size'] == 81920
         assert datetime.strptime(file1['mtime'], ISO_FORMAT)  # must not raise
 
-        list_archive = self.cmd(f'--repo={self.repository_location}', 'list', '--name=test', '--json-lines', '--format={sha256}')
+        list_archive = self.cmd(f'--repo={self.repository_location}', 'list', 'test', '--json-lines', '--format={sha256}')
         items = [json.loads(s) for s in list_archive.splitlines()]
         assert len(items) == 2
         file1 = items[1]
         assert file1['path'] == 'input/file1'
         assert file1['sha256'] == 'b2915eb69f260d8d3c25249195f2c8f4f716ea82ec760ae929732c0262442b2b'
 
-    def test_list_json_args(self):
-        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
-        self.cmd(f'--repo={self.repository_location}', 'list', '--json-lines', exit_code=2)
-        self.cmd(f'--repo={self.repository_location}', 'list', '--name=archive', '--json', exit_code=2)
-
     def test_log_json(self):
         self.create_test_files()
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
@@ -2448,7 +2443,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         # here we have both BORG_PASSPHRASE and BORG_NEW_PASSPHRASE set:
         self.cmd(f'--repo={self.repository_location}', 'key', 'change-passphrase')
         os.environ['BORG_PASSPHRASE'] = 'newpassphrase'
-        self.cmd(f'--repo={self.repository_location}', 'list')
+        self.cmd(f'--repo={self.repository_location}', 'rlist')
 
     def test_change_location_to_keyfile(self):
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
@@ -2919,15 +2914,15 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self.check_cache()
         self.cmd(f'--repo={self.repository_location}', 'create', 'test0', 'input')
         self.check_cache()
-        original_archive = self.cmd(f'--repo={self.repository_location}', 'list')
+        original_archive = self.cmd(f'--repo={self.repository_location}', 'rlist')
         self.cmd(f'--repo={self.repository_location}', 'recreate', 'test0', 'input/dir2',
                  '-e', 'input/dir2/file3', '--target=new-archive')
         self.check_cache()
-        archives = self.cmd(f'--repo={self.repository_location}', 'list')
+        archives = self.cmd(f'--repo={self.repository_location}', 'rlist')
         assert original_archive in archives
         assert 'new-archive' in archives
 
-        listing = self.cmd(f'--repo={self.repository_location}', 'list', '--name=new-archive', '--short')
+        listing = self.cmd(f'--repo={self.repository_location}', 'list', 'new-archive', '--short')
         assert 'file1' not in listing
         assert 'dir2/file2' in listing
         assert 'dir2/file3' not in listing
@@ -2939,7 +2934,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self.cmd(f'--repo={self.repository_location}', 'create', 'test0', 'input')
         self.cmd(f'--repo={self.repository_location}', 'recreate', 'test0', 'input/dir2', '-e', 'input/dir2/file3')
         self.check_cache()
-        listing = self.cmd(f'--repo={self.repository_location}', 'list', '--name=test0', '--short')
+        listing = self.cmd(f'--repo={self.repository_location}', 'list', 'test0', '--short')
         assert 'file1' not in listing
         assert 'dir2/file2' in listing
         assert 'dir2/file3' not in listing
@@ -2968,7 +2963,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
         self.cmd(f'--repo={self.repository_location}', 'create', 'test1', 'input', '--chunker-params', '7,9,8,128')
         self.cmd(f'--repo={self.repository_location}', 'create', 'test2', 'input', '--files-cache=disabled')
-        list = self.cmd(f'--repo={self.repository_location}', 'list', '--name=test1', 'input/large_file',
+        list = self.cmd(f'--repo={self.repository_location}', 'list', 'test1', 'input/large_file',
                         '--format', '{num_chunks} {unique_chunks}')
         num_chunks, unique_chunks = map(int, list.split(' '))
         # test1 and test2 do not deduplicate
@@ -2976,20 +2971,20 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self.cmd(f'--repo={self.repository_location}', 'recreate', '--chunker-params', 'default')
         self.check_cache()
         # test1 and test2 do deduplicate after recreate
-        assert int(self.cmd(f'--repo={self.repository_location}', 'list', '--name=test1', 'input/large_file', '--format={size}'))
-        assert not int(self.cmd(f'--repo={self.repository_location}', 'list', '--name=test1', 'input/large_file',
+        assert int(self.cmd(f'--repo={self.repository_location}', 'list', 'test1', 'input/large_file', '--format={size}'))
+        assert not int(self.cmd(f'--repo={self.repository_location}', 'list', 'test1', 'input/large_file',
                                 '--format', '{unique_chunks}'))
 
     def test_recreate_recompress(self):
         self.create_regular_file('compressible', size=10000)
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
         self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input', '-C', 'none')
-        file_list = self.cmd(f'--repo={self.repository_location}', 'list', '--name=test', 'input/compressible',
+        file_list = self.cmd(f'--repo={self.repository_location}', 'list', 'test', 'input/compressible',
                              '--format', '{size} {sha256}')
         size, sha256_before = file_list.split(' ')
         self.cmd(f'--repo={self.repository_location}', 'recreate', '-C', 'lz4', '--recompress')
         self.check_cache()
-        file_list = self.cmd(f'--repo={self.repository_location}', 'list', '--name=test', 'input/compressible',
+        file_list = self.cmd(f'--repo={self.repository_location}', 'list', 'test', 'input/compressible',
                              '--format', '{size} {sha256}')
         size, sha256_after = file_list.split(' ')
         assert sha256_before == sha256_after
@@ -3011,10 +3006,10 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self.create_regular_file('compressible', size=10000)
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
         self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
-        archives_before = self.cmd(f'--repo={self.repository_location}', 'list', '--name=test')
+        archives_before = self.cmd(f'--repo={self.repository_location}', 'list', 'test')
         self.cmd(f'--repo={self.repository_location}', 'recreate', '-n', '-e', 'input/compressible')
         self.check_cache()
-        archives_after = self.cmd(f'--repo={self.repository_location}', 'list', '--name=test')
+        archives_after = self.cmd(f'--repo={self.repository_location}', 'list', 'test')
         assert archives_after == archives_before
 
     def test_recreate_skips_nothing_to_do(self):
@@ -3519,12 +3514,12 @@ id: 2 / e29442 3506da 4e1ea7 / 25f62a 5a3d41 - 02
         # The repo should still be readable
         repo_info = self.cmd(f'--repo={self.repository_location}', 'info')
         assert 'All archives:' in repo_info
-        repo_list = self.cmd(f'--repo={self.repository_location}', 'list')
+        repo_list = self.cmd(f'--repo={self.repository_location}', 'rlist')
         assert 'test' in repo_list
         # The archive should still be readable
         archive_info = self.cmd(f'--repo={self.repository_location}', 'info', '--name=test')
         assert 'Archive name: test\n' in archive_info
-        archive_list = self.cmd(f'--repo={self.repository_location}', 'list', '--name=test')
+        archive_list = self.cmd(f'--repo={self.repository_location}', 'list', 'test')
         assert 'file1' in archive_list
         # Extracting the archive should work
         with changedir('output'):
@@ -3697,7 +3692,7 @@ class ArchiverCheckTestCase(ArchiverTestCaseBase):
         output = self.cmd(f'--repo={self.repository_location}', 'check', '--repair', exit_code=0)
         self.assert_in('New missing file chunk detected', output)
         self.cmd(f'--repo={self.repository_location}', 'check', exit_code=0)
-        output = self.cmd(f'--repo={self.repository_location}', 'list', '--name=archive1', '--format={health}#{path}{LF}', exit_code=0)
+        output = self.cmd(f'--repo={self.repository_location}', 'list', 'archive1', '--format={health}#{path}{LF}', exit_code=0)
         self.assert_in('broken#', output)
         # check that the file in the old archives has now a different chunk list without the killed chunk
         for archive_name in ('archive1', 'archive2'):
@@ -3728,7 +3723,7 @@ class ArchiverCheckTestCase(ArchiverTestCaseBase):
                 else:
                     self.fail('should not happen')
         # list is also all-healthy again
-        output = self.cmd(f'--repo={self.repository_location}', 'list', '--name=archive1', '--format={health}#{path}{LF}', exit_code=0)
+        output = self.cmd(f'--repo={self.repository_location}', 'list', 'archive1', '--format={health}#{path}{LF}', exit_code=0)
         self.assert_not_in('broken#', output)
 
     def test_missing_archive_item_chunk(self):
@@ -3811,7 +3806,7 @@ class ArchiverCheckTestCase(ArchiverTestCaseBase):
             repository.commit(compact=False)
         self.cmd(f'--repo={self.repository_location}', 'check', exit_code=1)
         self.cmd(f'--repo={self.repository_location}', 'check', '--repair', exit_code=0)
-        output = self.cmd(f'--repo={self.repository_location}', 'list')
+        output = self.cmd(f'--repo={self.repository_location}', 'rlist')
         self.assert_in('archive1', output)
         self.assert_in('archive1.1', output)
         self.assert_in('archive2', output)
@@ -3887,7 +3882,7 @@ class ManifestAuthenticationTest(ArchiverTestCaseBase):
             repository.commit(compact=False)
 
         with pytest.raises(TAMRequiredError):
-            self.cmd(f'--repo={self.repository_location}', 'list')
+            self.cmd(f'--repo={self.repository_location}', 'rlist')
 
     def test_not_required(self):
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
@@ -3903,23 +3898,23 @@ class ManifestAuthenticationTest(ArchiverTestCaseBase):
             del manifest['tam']
             repository.put(Manifest.MANIFEST_ID, key.encrypt(Manifest.MANIFEST_ID, msgpack.packb(manifest)))
             repository.commit(compact=False)
-        output = self.cmd(f'--repo={self.repository_location}', 'list', '--debug')
+        output = self.cmd(f'--repo={self.repository_location}', 'rlist', '--debug')
         assert 'archive1234' in output
         assert 'TAM not found and not required' in output
         # Run upgrade
         self.cmd(f'--repo={self.repository_location}', 'upgrade', '--tam')
         # Manifest must be authenticated now
-        output = self.cmd(f'--repo={self.repository_location}', 'list', '--debug')
+        output = self.cmd(f'--repo={self.repository_location}', 'rlist', '--debug')
         assert 'archive1234' in output
         assert 'TAM-verified manifest' in output
         # Try to spoof / modify pre-1.0.9
         self.spoof_manifest(repository)
         # Fails
         with pytest.raises(TAMRequiredError):
-            self.cmd(f'--repo={self.repository_location}', 'list')
+            self.cmd(f'--repo={self.repository_location}', 'rlist')
         # Force upgrade
         self.cmd(f'--repo={self.repository_location}', 'upgrade', '--tam', '--force')
-        self.cmd(f'--repo={self.repository_location}', 'list')
+        self.cmd(f'--repo={self.repository_location}', 'rlist')
 
     def test_disable(self):
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
@@ -3927,7 +3922,7 @@ class ManifestAuthenticationTest(ArchiverTestCaseBase):
         self.cmd(f'--repo={self.repository_location}', 'upgrade', '--disable-tam')
         repository = Repository(self.repository_path, exclusive=True)
         self.spoof_manifest(repository)
-        assert not self.cmd(f'--repo={self.repository_location}', 'list')
+        assert not self.cmd(f'--repo={self.repository_location}', 'rlist')
 
     def test_disable2(self):
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
@@ -3935,7 +3930,7 @@ class ManifestAuthenticationTest(ArchiverTestCaseBase):
         repository = Repository(self.repository_path, exclusive=True)
         self.spoof_manifest(repository)
         self.cmd(f'--repo={self.repository_location}', 'upgrade', '--disable-tam')
-        assert not self.cmd(f'--repo={self.repository_location}', 'list')
+        assert not self.cmd(f'--repo={self.repository_location}', 'rlist')
 
 
 class RemoteArchiverTestCase(ArchiverTestCase):
@@ -4043,7 +4038,7 @@ class ArchiverCorruptionTestCase(ArchiverTestCaseBase):
     def test_chunks_archive(self):
         self.cmd(f'--repo={self.repository_location}', 'create', 'test1', 'input')
         # Find ID of test1 so we can corrupt it later :)
-        target_id = self.cmd(f'--repo={self.repository_location}', 'list', '--format={id}{LF}').strip()
+        target_id = self.cmd(f'--repo={self.repository_location}', 'rlist', '--format={id}{LF}').strip()
         self.cmd(f'--repo={self.repository_location}', 'create', 'test2', 'input')
 
         # Force cache sync, creating archive chunks of test1 and test2 in chunks.archive.d

From 9e5a8a352f1256b792d76431a7a705eb0490e756 Mon Sep 17 00:00:00 2001
From: Thomas Waldmann <tw@waldmann-edv.de>
Date: Tue, 21 Jun 2022 01:04:41 +0200
Subject: [PATCH 064/160] borg info -a ARCH_GLOB, borg rinfo

---
 src/borg/archiver.py           | 107 ++++++++++++++++++---------------
 src/borg/testsuite/archiver.py |  96 ++++++++++++++---------------
 2 files changed, 108 insertions(+), 95 deletions(-)

diff --git a/src/borg/archiver.py b/src/borg/archiver.py
index 37d7464b8..a1ad72b67 100644
--- a/src/borg/archiver.py
+++ b/src/borg/archiver.py
@@ -1752,23 +1752,48 @@ class Archiver:
 
         return self.exit_code
 
+    @with_repository(cache=True, compatibility=(Manifest.Operation.READ,))
+    def do_rinfo(self, args, repository, manifest, key, cache):
+        """Show repository infos"""
+        info = basic_json_data(manifest, cache=cache, extra={
+            'security_dir': cache.security_manager.dir,
+        })
+
+        if args.json:
+            json_print(info)
+        else:
+            encryption = 'Encrypted: '
+            if key.NAME in ('plaintext', 'authenticated'):
+                encryption += 'No'
+            else:
+                encryption += 'Yes (%s)' % key.NAME
+            if key.NAME.startswith('key file'):
+                encryption += '\nKey file: %s' % key.find_key()
+            info['encryption'] = encryption
+
+            print(textwrap.dedent("""
+            Repository ID: {id}
+            Location: {location}
+            {encryption}
+            Cache: {cache.path}
+            Security dir: {security_dir}
+            """).strip().format(
+                id=bin_to_hex(repository.id),
+                location=repository._location.canonical_path(),
+                **info))
+            print(DASHES)
+            print(STATS_HEADER)
+            print(str(cache))
+        return self.exit_code
+
     @with_repository(cache=True, compatibility=(Manifest.Operation.READ,))
     def do_info(self, args, repository, manifest, key, cache):
         """Show archive details such as disk space used"""
-        if any((args.name, args.first, args.last, args.prefix is not None, args.glob_archives)):
-            return self._info_archives(args, repository, manifest, key, cache)
-        else:
-            return self._info_repository(args, repository, manifest, key, cache)
-
-    def _info_archives(self, args, repository, manifest, key, cache):
         def format_cmdline(cmdline):
             return remove_surrogates(' '.join(shlex.quote(x) for x in cmdline))
 
-        if args.name:
-            archive_names = (args.name,)
-        else:
-            args.consider_checkpoints = True
-            archive_names = tuple(x.name for x in manifest.archives.list_considering(args))
+        args.consider_checkpoints = True
+        archive_names = tuple(x.name for x in manifest.archives.list_considering(args))
 
         output_data = []
 
@@ -1809,38 +1834,6 @@ class Archiver:
             }))
         return self.exit_code
 
-    def _info_repository(self, args, repository, manifest, key, cache):
-        info = basic_json_data(manifest, cache=cache, extra={
-            'security_dir': cache.security_manager.dir,
-        })
-
-        if args.json:
-            json_print(info)
-        else:
-            encryption = 'Encrypted: '
-            if key.NAME in ('plaintext', 'authenticated'):
-                encryption += 'No'
-            else:
-                encryption += 'Yes (%s)' % key.NAME
-            if key.NAME.startswith('key file'):
-                encryption += '\nKey file: %s' % key.find_key()
-            info['encryption'] = encryption
-
-            print(textwrap.dedent("""
-            Repository ID: {id}
-            Location: {location}
-            {encryption}
-            Cache: {cache.path}
-            Security dir: {security_dir}
-            """).strip().format(
-                id=bin_to_hex(repository.id),
-                location=repository._location.canonical_path(),
-                **info))
-            print(DASHES)
-            print(STATS_HEADER)
-            print(str(cache))
-        return self.exit_code
-
     @with_repository(exclusive=True, compatibility=(Manifest.Operation.DELETE,))
     def do_prune(self, args, repository, manifest, key):
         """Prune repository archives according to specified rules"""
@@ -4335,9 +4328,31 @@ class Archiver:
         subparser.add_argument('topic', metavar='TOPIC', type=str, nargs='?',
                                help='additional help on TOPIC')
 
+        # borg rinfo
+        rinfo_epilog = process_epilog("""
+        This command displays detailed information about the repository.
+
+        Please note that the deduplicated sizes of the individual archives do not add
+        up to the deduplicated size of the repository ("all archives"), because the two
+        are meaning different things:
+
+        This archive / deduplicated size = amount of data stored ONLY for this archive
+        = unique chunks of this archive.
+        All archives / deduplicated size = amount of data stored in the repo
+        = all chunks in the repository.
+        """)
+        subparser = subparsers.add_parser('rinfo', parents=[common_parser], add_help=False,
+                                          description=self.do_rinfo.__doc__,
+                                          epilog=rinfo_epilog,
+                                          formatter_class=argparse.RawDescriptionHelpFormatter,
+                                          help='show repository information')
+        subparser.set_defaults(func=self.do_rinfo)
+        subparser.add_argument('--json', action='store_true',
+                               help='format output as JSON')
+
         # borg info
         info_epilog = process_epilog("""
-        This command displays detailed information about the specified archive or repository.
+        This command displays detailed information about the specified archive.
 
         Please note that the deduplicated sizes of the individual archives do not add
         up to the deduplicated size of the repository ("all archives"), because the two
@@ -4359,8 +4374,6 @@ class Archiver:
                                           formatter_class=argparse.RawDescriptionHelpFormatter,
                                           help='show repository or archive information')
         subparser.set_defaults(func=self.do_info)
-        subparser.add_argument('--name', dest='name', metavar='NAME', type=NameSpec,
-                               help='specify the archive name')
         subparser.add_argument('--json', action='store_true',
                                help='format output as JSON')
         define_archive_filters_group(subparser)
@@ -5293,7 +5306,7 @@ class Archiver:
                 parser.error('Need at least one PATH argument.')
         if not getattr(args, 'lock', True):  # Option --bypass-lock sets args.lock = False
             bypass_allowed = {self.do_check, self.do_config, self.do_diff,
-                              self.do_export_tar, self.do_extract, self.do_info,
+                              self.do_export_tar, self.do_extract, self.do_info, self.do_rinfo,
                               self.do_list, self.do_rlist, self.do_mount, self.do_umount}
             if func not in bypass_allowed:
                 raise Error('Not allowed to bypass locking mechanism for chosen command')
diff --git a/src/borg/testsuite/archiver.py b/src/borg/testsuite/archiver.py
index ce97c3fe7..c5b5c10a5 100644
--- a/src/borg/testsuite/archiver.py
+++ b/src/borg/testsuite/archiver.py
@@ -431,11 +431,11 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         for name in expected:
             self.assert_in(name, list_output)
         self.assert_dirs_equal('input', 'output/input')
-        info_output = self.cmd(f'--repo={self.repository_location}', 'info', '--name=test')
+        info_output = self.cmd(f'--repo={self.repository_location}', 'info', '-a', 'test')
         item_count = 5 if has_lchflags else 6  # one file is UF_NODUMP
         self.assert_in('Number of files: %d' % item_count, info_output)
         shutil.rmtree(self.cache_path)
-        info_output2 = self.cmd(f'--repo={self.repository_location}', 'info', '--name=test')
+        info_output2 = self.cmd(f'--repo={self.repository_location}', 'info', '-a', 'test')
 
         def filter(output):
             # filter for interesting "info" output, ignore cache rebuilding related stuff
@@ -761,16 +761,16 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         security_dir = self.get_security_dir()
         os.rename(self.repository_path, self.repository_path + '_new')
         with environment_variable(BORG_RELOCATED_REPO_ACCESS_IS_OK='yes'):
-            self.cmd(f'--repo={self.repository_location}_new', 'info')
+            self.cmd(f'--repo={self.repository_location}_new', 'rinfo')
         with open(os.path.join(security_dir, 'location')) as fd:
             location = fd.read()
             assert location == Location(self.repository_location + '_new').canonical_path()
         # Needs no confirmation anymore
-        self.cmd(f'--repo={self.repository_location}_new', 'info')
+        self.cmd(f'--repo={self.repository_location}_new', 'rinfo')
         shutil.rmtree(self.cache_path)
-        self.cmd(f'--repo={self.repository_location}_new', 'info')
+        self.cmd(f'--repo={self.repository_location}_new', 'rinfo')
         shutil.rmtree(security_dir)
-        self.cmd(f'--repo={self.repository_location}_new', 'info')
+        self.cmd(f'--repo={self.repository_location}_new', 'rinfo')
         for file in ('location', 'key-type', 'manifest-timestamp'):
             assert os.path.exists(os.path.join(security_dir, file))
 
@@ -780,27 +780,27 @@ class ArchiverTestCase(ArchiverTestCaseBase):
             fd.write('something outdated')
         # This is fine, because the cache still has the correct information. security_dir and cache can disagree
         # if older versions are used to confirm a renamed repository.
-        self.cmd(f'--repo={self.repository_location}', 'info')
+        self.cmd(f'--repo={self.repository_location}', 'rinfo')
 
     def test_unknown_unencrypted(self):
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=none')
         # Ok: repository is known
-        self.cmd(f'--repo={self.repository_location}', 'info')
+        self.cmd(f'--repo={self.repository_location}', 'rinfo')
 
         # Ok: repository is still known (through security_dir)
         shutil.rmtree(self.cache_path)
-        self.cmd(f'--repo={self.repository_location}', 'info')
+        self.cmd(f'--repo={self.repository_location}', 'rinfo')
 
         # Needs confirmation: cache and security dir both gone (eg. another host or rm -rf ~)
         shutil.rmtree(self.cache_path)
         shutil.rmtree(self.get_security_dir())
         if self.FORK_DEFAULT:
-            self.cmd(f'--repo={self.repository_location}', 'info', exit_code=EXIT_ERROR)
+            self.cmd(f'--repo={self.repository_location}', 'rinfo', exit_code=EXIT_ERROR)
         else:
             with pytest.raises(Cache.CacheInitAbortedError):
-                self.cmd(f'--repo={self.repository_location}', 'info')
+                self.cmd(f'--repo={self.repository_location}', 'rinfo')
         with environment_variable(BORG_UNKNOWN_UNENCRYPTED_REPO_ACCESS_IS_OK='yes'):
-            self.cmd(f'--repo={self.repository_location}', 'info')
+            self.cmd(f'--repo={self.repository_location}', 'rinfo')
 
     def test_strip_components(self):
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
@@ -1280,13 +1280,13 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         create_json = json.loads(self.cmd(f'--repo={self.repository_location}', 'create',
                                           '--no-cache-sync', '--json', '--error',
                                           'test', 'input'))  # ignore experimental warning
-        info_json = json.loads(self.cmd(f'--repo={self.repository_location}', 'info', '--name=test', '--json'))
+        info_json = json.loads(self.cmd(f'--repo={self.repository_location}', 'info', '-a', 'test', '--json'))
         create_stats = create_json['cache']['stats']
         info_stats = info_json['cache']['stats']
         assert create_stats == info_stats
         self.cmd(f'--repo={self.repository_location}', 'delete', '--cache-only')
         self.cmd(f'--repo={self.repository_location}', 'create', '--no-cache-sync', 'test2', 'input')
-        self.cmd(f'--repo={self.repository_location}', 'info')
+        self.cmd(f'--repo={self.repository_location}', 'rinfo')
         self.cmd(f'--repo={self.repository_location}', 'check')
 
     def test_extract_pattern_opt(self):
@@ -1524,9 +1524,9 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self.create_regular_file('file1', size=1024 * 80)
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
         self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
-        info_repo = self.cmd(f'--repo={self.repository_location}', 'info')
+        info_repo = self.cmd(f'--repo={self.repository_location}', 'rinfo')
         assert 'All archives:' in info_repo
-        info_archive = self.cmd(f'--repo={self.repository_location}', 'info', '--name=test')
+        info_archive = self.cmd(f'--repo={self.repository_location}', 'info', '-a', 'test')
         assert 'Archive name: test\n' in info_archive
         info_archive = self.cmd(f'--repo={self.repository_location}', 'info', '--first', '1')
         assert 'Archive name: test\n' in info_archive
@@ -1535,7 +1535,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self.create_regular_file('file1', size=1024 * 80)
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
         self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
-        info_repo = json.loads(self.cmd(f'--repo={self.repository_location}', 'info', '--json'))
+        info_repo = json.loads(self.cmd(f'--repo={self.repository_location}', 'rinfo', '--json'))
         repository = info_repo['repository']
         assert len(repository['id']) == 64
         assert 'last_modified' in repository
@@ -1547,7 +1547,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         assert all(isinstance(o, int) for o in stats.values())
         assert all(key in stats for key in ('total_chunks', 'total_size', 'total_unique_chunks', 'unique_size'))
 
-        info_archive = json.loads(self.cmd(f'--repo={self.repository_location}', 'info', '--name=test', '--json'))
+        info_archive = json.loads(self.cmd(f'--repo={self.repository_location}', 'info', '-a', 'test', '--json'))
         assert info_repo['repository'] == info_archive['repository']
         assert info_repo['cache'] == info_archive['cache']
         archives = info_archive['archives']
@@ -1576,17 +1576,17 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self.cmd(f'--repo={self.repository_location}', 'create', 'test2', 'input', '--comment', 'this is the comment')
         self.cmd(f'--repo={self.repository_location}', 'create', 'test3', 'input', '--comment', '"deleted" comment')
         self.cmd(f'--repo={self.repository_location}', 'create', 'test4', 'input', '--comment', 'preserved comment')
-        assert 'Comment: \n' in self.cmd(f'--repo={self.repository_location}', 'info', '--name=test1')
-        assert 'Comment: this is the comment' in self.cmd(f'--repo={self.repository_location}', 'info', '--name=test2')
+        assert 'Comment: \n' in self.cmd(f'--repo={self.repository_location}', 'info', '-a', 'test1')
+        assert 'Comment: this is the comment' in self.cmd(f'--repo={self.repository_location}', 'info', '-a', 'test2')
 
         self.cmd(f'--repo={self.repository_location}', 'recreate', '-a', 'test1', '--comment', 'added comment')
         self.cmd(f'--repo={self.repository_location}', 'recreate', '-a', 'test2', '--comment', 'modified comment')
         self.cmd(f'--repo={self.repository_location}', 'recreate', '-a', 'test3', '--comment', '')
         self.cmd(f'--repo={self.repository_location}', 'recreate', '-a', 'test4', '12345')
-        assert 'Comment: added comment' in self.cmd(f'--repo={self.repository_location}', 'info', '--name=test1')
-        assert 'Comment: modified comment' in self.cmd(f'--repo={self.repository_location}', 'info', '--name=test2')
-        assert 'Comment: \n' in self.cmd(f'--repo={self.repository_location}', 'info', '--name=test3')
-        assert 'Comment: preserved comment' in self.cmd(f'--repo={self.repository_location}', 'info', '--name=test4')
+        assert 'Comment: added comment' in self.cmd(f'--repo={self.repository_location}', 'info', '-a', 'test1')
+        assert 'Comment: modified comment' in self.cmd(f'--repo={self.repository_location}', 'info', '-a', 'test2')
+        assert 'Comment: \n' in self.cmd(f'--repo={self.repository_location}', 'info', '-a', 'test3')
+        assert 'Comment: preserved comment' in self.cmd(f'--repo={self.repository_location}', 'info', '-a', 'test4')
 
     def test_delete(self):
         self.create_regular_file('file1', size=1024 * 80)
@@ -1749,14 +1749,14 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         with self.read_only(self.repository_path):
             # verify that command normally doesn't work with read-only repo
             if self.FORK_DEFAULT:
-                self.cmd(f'--repo={self.repository_location}', 'info', exit_code=EXIT_ERROR)
+                self.cmd(f'--repo={self.repository_location}', 'rinfo', exit_code=EXIT_ERROR)
             else:
                 with pytest.raises((LockFailed, RemoteRepository.RPCError)) as excinfo:
-                    self.cmd(f'--repo={self.repository_location}', 'info')
+                    self.cmd(f'--repo={self.repository_location}', 'rinfo')
                 if isinstance(excinfo.value, RemoteRepository.RPCError):
                     assert excinfo.value.exception_class == 'LockFailed'
             # verify that command works with read-only repo when using --bypass-lock
-            self.cmd(f'--repo={self.repository_location}', 'info', '--bypass-lock')
+            self.cmd(f'--repo={self.repository_location}', 'rinfo', '--bypass-lock')
 
     def test_readonly_list(self):
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
@@ -1848,7 +1848,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
             self.cmd_raises_unknown_feature([f'--repo={self.repository_location}', 'extract', 'test'])
 
         self.cmd_raises_unknown_feature([f'--repo={self.repository_location}', 'rlist'])
-        self.cmd_raises_unknown_feature([f'--repo={self.repository_location}', 'info', '--name=test'])
+        self.cmd_raises_unknown_feature([f'--repo={self.repository_location}', 'info', '-a', 'test'])
 
     def test_unknown_feature_on_rename(self):
         print(self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey'))
@@ -2447,34 +2447,34 @@ class ArchiverTestCase(ArchiverTestCaseBase):
 
     def test_change_location_to_keyfile(self):
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
-        log = self.cmd(f'--repo={self.repository_location}', 'info')
+        log = self.cmd(f'--repo={self.repository_location}', 'rinfo')
         assert '(repokey)' in log
         self.cmd(f'--repo={self.repository_location}', 'key', 'change-location', 'keyfile')
-        log = self.cmd(f'--repo={self.repository_location}', 'info')
+        log = self.cmd(f'--repo={self.repository_location}', 'rinfo')
         assert '(key file)' in log
 
     def test_change_location_to_b2keyfile(self):
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey-blake2')
-        log = self.cmd(f'--repo={self.repository_location}', 'info')
+        log = self.cmd(f'--repo={self.repository_location}', 'rinfo')
         assert '(repokey BLAKE2b)' in log
         self.cmd(f'--repo={self.repository_location}', 'key', 'change-location', 'keyfile')
-        log = self.cmd(f'--repo={self.repository_location}', 'info')
+        log = self.cmd(f'--repo={self.repository_location}', 'rinfo')
         assert '(key file BLAKE2b)' in log
 
     def test_change_location_to_repokey(self):
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=keyfile')
-        log = self.cmd(f'--repo={self.repository_location}', 'info')
+        log = self.cmd(f'--repo={self.repository_location}', 'rinfo')
         assert '(key file)' in log
         self.cmd(f'--repo={self.repository_location}', 'key', 'change-location', 'repokey')
-        log = self.cmd(f'--repo={self.repository_location}', 'info')
+        log = self.cmd(f'--repo={self.repository_location}', 'rinfo')
         assert '(repokey)' in log
 
     def test_change_location_to_b2repokey(self):
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=keyfile-blake2')
-        log = self.cmd(f'--repo={self.repository_location}', 'info')
+        log = self.cmd(f'--repo={self.repository_location}', 'rinfo')
         assert '(key file BLAKE2b)' in log
         self.cmd(f'--repo={self.repository_location}', 'key', 'change-location', 'repokey')
-        log = self.cmd(f'--repo={self.repository_location}', 'info')
+        log = self.cmd(f'--repo={self.repository_location}', 'rinfo')
         assert '(repokey BLAKE2b)' in log
 
     def test_break_lock(self):
@@ -2996,7 +2996,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self.cmd(f'--repo={self.repository_location}', 'create', 'test0', 'input')
         self.cmd(f'--repo={self.repository_location}', 'recreate', 'test0', '--timestamp', "1970-01-02T00:00:00",
                  '--comment', 'test')
-        info = self.cmd(f'--repo={self.repository_location}', 'info', '--name=test0').splitlines()
+        info = self.cmd(f'--repo={self.repository_location}', 'info', '-a', 'test0').splitlines()
         dtime = datetime(1970, 1, 2) + local_timezone.utcoffset(None)
         s_time = dtime.strftime("%Y-%m-%d")
         assert any([re.search(r'Time \(start\).+ %s' % s_time, item) for item in info])
@@ -3016,10 +3016,10 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self.create_regular_file('file1', size=1024 * 80)
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
         self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
-        info_before = self.cmd(f'--repo={self.repository_location}', 'info', '--name=test')
+        info_before = self.cmd(f'--repo={self.repository_location}', 'info', '-a', 'test')
         self.cmd(f'--repo={self.repository_location}', 'recreate', '--chunker-params', 'default')
         self.check_cache()
-        info_after = self.cmd(f'--repo={self.repository_location}', 'info', '--name=test')
+        info_after = self.cmd(f'--repo={self.repository_location}', 'info', '-a', 'test')
         assert info_before == info_after  # includes archive ID
 
     def test_with_lock(self):
@@ -3492,7 +3492,7 @@ id: 2 / e29442 3506da 4e1ea7 / 25f62a 5a3d41 - 02
 
     def test_do_not_mention_archive_if_you_can_not_find_repo(self):
         """https://github.com/borgbackup/borg/issues/6014"""
-        output = self.cmd(f'--repo={self.repository_location}-this-repository-does-not-exist', 'info', '--name=test',
+        output = self.cmd(f'--repo={self.repository_location}-this-repository-does-not-exist', 'info', '-a', 'test',
                           exit_code=2, fork=True)
         self.assert_in('this-repository-does-not-exist', output)
         self.assert_not_in('this-repository-does-not-exist::test', output)
@@ -3512,12 +3512,12 @@ id: 2 / e29442 3506da 4e1ea7 / 25f62a 5a3d41 - 02
         os.remove(os.path.join(self.get_security_dir(), 'nonce'))
 
         # The repo should still be readable
-        repo_info = self.cmd(f'--repo={self.repository_location}', 'info')
+        repo_info = self.cmd(f'--repo={self.repository_location}', 'rinfo')
         assert 'All archives:' in repo_info
         repo_list = self.cmd(f'--repo={self.repository_location}', 'rlist')
         assert 'test' in repo_list
         # The archive should still be readable
-        archive_info = self.cmd(f'--repo={self.repository_location}', 'info', '--name=test')
+        archive_info = self.cmd(f'--repo={self.repository_location}', 'info', '-a', 'test')
         assert 'Archive name: test\n' in archive_info
         archive_list = self.cmd(f'--repo={self.repository_location}', 'list', 'test')
         assert 'file1' in archive_list
@@ -3597,7 +3597,7 @@ id: 2 / e29442 3506da 4e1ea7 / 25f62a 5a3d41 - 02
         with Repository(self.repository_path) as repository:
             _, key = Manifest.load(repository, Manifest.NO_OPERATION_CHECK)
         assert key._encrypted_key_algorithm == 'argon2 chacha20-poly1305'
-        self.cmd(f'--repo={self.repository_location}', 'info')
+        self.cmd(f'--repo={self.repository_location}', 'rinfo')
 
 
 @unittest.skipUnless('binary' in BORG_EXES, 'no borg.exe available')
@@ -4009,7 +4009,7 @@ class ArchiverCorruptionTestCase(ArchiverTestCaseBase):
         super().setUp()
         self.create_test_files()
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
-        self.cache_path = json.loads(self.cmd(f'--repo={self.repository_location}', 'info', '--json'))['cache']['path']
+        self.cache_path = json.loads(self.cmd(f'--repo={self.repository_location}', 'rinfo', '--json'))['cache']['path']
 
     def corrupt(self, file, amount=1):
         with open(file, 'r+b') as fd:
@@ -4022,11 +4022,11 @@ class ArchiverCorruptionTestCase(ArchiverTestCaseBase):
         self.corrupt(os.path.join(self.cache_path, 'chunks'))
 
         if self.FORK_DEFAULT:
-            out = self.cmd(f'--repo={self.repository_location}', 'info', exit_code=2)
+            out = self.cmd(f'--repo={self.repository_location}', 'rinfo', exit_code=2)
             assert 'failed integrity check' in out
         else:
             with pytest.raises(FileIntegrityError):
-                self.cmd(f'--repo={self.repository_location}', 'info')
+                self.cmd(f'--repo={self.repository_location}', 'rinfo')
 
     def test_cache_files(self):
         self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
@@ -4043,7 +4043,7 @@ class ArchiverCorruptionTestCase(ArchiverTestCaseBase):
 
         # Force cache sync, creating archive chunks of test1 and test2 in chunks.archive.d
         self.cmd(f'--repo={self.repository_location}', 'delete', '--cache-only')
-        self.cmd(f'--repo={self.repository_location}', 'info', '--json')
+        self.cmd(f'--repo={self.repository_location}', 'rinfo', '--json')
 
         chunks_archive = os.path.join(self.cache_path, 'chunks.archive.d')
         assert len(os.listdir(chunks_archive)) == 4  # two archives, one chunks cache and one .integrity file each
@@ -4074,7 +4074,7 @@ class ArchiverCorruptionTestCase(ArchiverTestCaseBase):
         with open(config_path, 'w') as fd:
             config.write(fd)
 
-        out = self.cmd(f'--repo={self.repository_location}', 'info')
+        out = self.cmd(f'--repo={self.repository_location}', 'rinfo')
         assert 'Cache integrity data not available: old Borg version modified the cache.' in out
 
 

From 34b6248d755784048353de256faf0119804fe184 Mon Sep 17 00:00:00 2001
From: Thomas Waldmann <tw@waldmann-edv.de>
Date: Tue, 21 Jun 2022 02:10:48 +0200
Subject: [PATCH 065/160] borg delete -a ARCH_GLOB, borg rdelete

---
 src/borg/archiver.py           | 205 +++++++++++++++++----------------
 src/borg/testsuite/archiver.py |  39 ++++---
 2 files changed, 125 insertions(+), 119 deletions(-)

diff --git a/src/borg/archiver.py b/src/borg/archiver.py
index a1ad72b67..436aa8ddc 100644
--- a/src/borg/archiver.py
+++ b/src/borg/archiver.py
@@ -679,7 +679,7 @@ class Archiver:
             # now build files cache
             rc1 = self.do_create(self.parse_args([f'--repo={repo}', 'create', compression,
                                                   'borg-benchmark-crud2', path]))
-            rc2 = self.do_delete(self.parse_args([f'--repo={repo}', 'delete', '--name=borg-benchmark-crud2']))
+            rc2 = self.do_delete(self.parse_args([f'--repo={repo}', 'delete', '-a', 'borg-benchmark-crud2']))
             assert rc1 == rc2 == 0
             # measure a no-change update (archive1 is still present)
             t_start = time.monotonic()
@@ -687,7 +687,7 @@ class Archiver:
                                                   'borg-benchmark-crud3', path]))
             t_end = time.monotonic()
             dt_update = t_end - t_start
-            rc2 = self.do_delete(self.parse_args([f'--repo={repo}', 'delete', '--name=borg-benchmark-crud3']))
+            rc2 = self.do_delete(self.parse_args([f'--repo={repo}', 'delete', '-a', 'borg-benchmark-crud3']))
             assert rc1 == rc2 == 0
             # measure extraction (dry-run: without writing result to disk)
             t_start = time.monotonic()
@@ -698,7 +698,7 @@ class Archiver:
             assert rc == 0
             # measure archive deletion (of LAST present archive with the data)
             t_start = time.monotonic()
-            rc = self.do_delete(self.parse_args([f'--repo={repo}', 'delete', '--name=borg-benchmark-crud1']))
+            rc = self.do_delete(self.parse_args([f'--repo={repo}', 'delete', '-a', 'borg-benchmark-crud1']))
             t_end = time.monotonic()
             dt_delete = t_end - t_start
             assert rc == 0
@@ -1515,35 +1515,80 @@ class Archiver:
         return self.exit_code
 
     @with_repository(exclusive=True, manifest=False)
-    def do_delete(self, args, repository):
-        """Delete an existing repository or archives"""
-        archive_filter_specified = any((args.first, args.last, args.prefix is not None, args.glob_archives))
-        explicit_archives_specified = args.name or args.archives
+    def do_rdelete(self, args, repository):
+        """Delete a repository"""
         self.output_list = args.output_list
-        if archive_filter_specified and explicit_archives_specified:
-            self.print_error('Mixing archive filters and explicitly named archives is not supported.')
-            return self.exit_code
-        if archive_filter_specified or explicit_archives_specified:
-            return self._delete_archives(args, repository)
-        else:
-            return self._delete_repository(args, repository)
-
-    def _delete_archives(self, args, repository):
-        """Delete archives"""
         dry_run = args.dry_run
+        keep_security_info = args.keep_security_info
 
-        manifest, key = Manifest.load(repository, (Manifest.Operation.DELETE,))
+        if not args.cache_only:
+            if args.forced == 0:  # without --force, we let the user see the archives list and confirm.
+                id = bin_to_hex(repository.id)
+                location = repository._location.canonical_path()
+                msg = []
+                try:
+                    manifest, key = Manifest.load(repository, Manifest.NO_OPERATION_CHECK)
+                    n_archives = len(manifest.archives)
+                    msg.append(f"You requested to completely DELETE the following repository "
+                               f"*including* {n_archives} archives it contains:")
+                except NoManifestError:
+                    n_archives = None
+                    msg.append("You requested to completely DELETE the following repository "
+                               "*including* all archives it may contain:")
 
-        if args.name or args.archives:
-            archives = list(args.archives)
-            if args.name:
-                archives.insert(0, args.name)
-            archive_names = tuple(archives)
+                msg.append(DASHES)
+                msg.append(f"Repository ID: {id}")
+                msg.append(f"Location: {location}")
+
+                if self.output_list:
+                    msg.append("")
+                    msg.append("Archives:")
+
+                    if n_archives is not None:
+                        if n_archives > 0:
+                            for archive_info in manifest.archives.list(sort_by=['ts']):
+                                msg.append(format_archive(archive_info))
+                        else:
+                            msg.append("This repository seems to not have any archives.")
+                    else:
+                        msg.append("This repository seems to have no manifest, so we can't "
+                                   "tell anything about its contents.")
+
+                msg.append(DASHES)
+                msg.append("Type 'YES' if you understand this and want to continue: ")
+                msg = '\n'.join(msg)
+                if not yes(msg, false_msg="Aborting.", invalid_msg='Invalid answer, aborting.', truish=('YES',),
+                           retry=False, env_var_override='BORG_DELETE_I_KNOW_WHAT_I_AM_DOING'):
+                    self.exit_code = EXIT_ERROR
+                    return self.exit_code
+            if not dry_run:
+                repository.destroy()
+                logger.info("Repository deleted.")
+                if not keep_security_info:
+                    SecurityManager.destroy(repository)
+            else:
+                logger.info("Would delete repository.")
+                logger.info("Would %s security info." % ("keep" if keep_security_info else "delete"))
+        if not dry_run:
+            Cache.destroy(repository)
+            logger.info("Cache deleted.")
         else:
-            args.consider_checkpoints = True
-            archive_names = tuple(x.name for x in manifest.archives.list_considering(args))
-            if not archive_names:
-                return self.exit_code
+            logger.info("Would delete cache.")
+        return self.exit_code
+
+    @with_repository(exclusive=True, manifest=False)
+    def do_delete(self, args, repository):
+        """Delete archives"""
+        self.output_list = args.output_list
+        dry_run = args.dry_run
+        manifest, key = Manifest.load(repository, (Manifest.Operation.DELETE,))
+        archive_names = tuple(x.name for x in manifest.archives.list_considering(args))
+        if not archive_names:
+            return self.exit_code
+        if args.glob_archives is None and args.first == 0 and args.last == 0:
+            self.print_error("Aborting: if you really want to delete all archives, please use -a '*' "
+                             "or just delete the whole repository (might be much faster).")
+            return EXIT_ERROR
 
         if args.forced == 2:
             deleted = False
@@ -1605,66 +1650,6 @@ class Archiver:
 
         return self.exit_code
 
-    def _delete_repository(self, args, repository):
-        """Delete a repository"""
-        dry_run = args.dry_run
-        keep_security_info = args.keep_security_info
-
-        if not args.cache_only:
-            if args.forced == 0:  # without --force, we let the user see the archives list and confirm.
-                id = bin_to_hex(repository.id)
-                location = repository._location.canonical_path()
-                msg = []
-                try:
-                    manifest, key = Manifest.load(repository, Manifest.NO_OPERATION_CHECK)
-                    n_archives = len(manifest.archives)
-                    msg.append(f"You requested to completely DELETE the following repository "
-                               f"*including* {n_archives} archives it contains:")
-                except NoManifestError:
-                    n_archives = None
-                    msg.append("You requested to completely DELETE the following repository "
-                               "*including* all archives it may contain:")
-
-                msg.append(DASHES)
-                msg.append(f"Repository ID: {id}")
-                msg.append(f"Location: {location}")
-
-                if self.output_list:
-                    msg.append("")
-                    msg.append("Archives:")
-
-                    if n_archives is not None:
-                        if n_archives > 0:
-                            for archive_info in manifest.archives.list(sort_by=['ts']):
-                                msg.append(format_archive(archive_info))
-                        else:
-                            msg.append("This repository seems to not have any archives.")
-                    else:
-                        msg.append("This repository seems to have no manifest, so we can't "
-                                   "tell anything about its contents.")
-
-                msg.append(DASHES)
-                msg.append("Type 'YES' if you understand this and want to continue: ")
-                msg = '\n'.join(msg)
-                if not yes(msg, false_msg="Aborting.", invalid_msg='Invalid answer, aborting.', truish=('YES',),
-                           retry=False, env_var_override='BORG_DELETE_I_KNOW_WHAT_I_AM_DOING'):
-                    self.exit_code = EXIT_ERROR
-                    return self.exit_code
-            if not dry_run:
-                repository.destroy()
-                logger.info("Repository deleted.")
-                if not keep_security_info:
-                    SecurityManager.destroy(repository)
-            else:
-                logger.info("Would delete repository.")
-                logger.info("Would %s security info." % ("keep" if keep_security_info else "delete"))
-        if not dry_run:
-            Cache.destroy(repository)
-            logger.info("Cache deleted.")
-        else:
-            logger.info("Would delete cache.")
-        return self.exit_code
-
     def do_mount(self, args):
         """Mount archive or an entire repository as a FUSE filesystem"""
         # Perform these checks before opening the repository and asking for a passphrase.
@@ -4062,18 +4047,42 @@ class Archiver:
         subparser.add_argument('output', metavar='OUTPUT', type=argparse.FileType('wb'),
                                help='Output file')
 
-        # borg delete
-        delete_epilog = process_epilog("""
-        This command deletes an archive from the repository or the complete repository.
-
-        Important: When deleting archives, repository disk space is **not** freed until
-        you run ``borg compact``.
+        # borg rdelete
+        rdelete_epilog = process_epilog("""
+        This command deletes the complete repository.
 
         When you delete a complete repository, the security info and local cache for it
         (if any) are also deleted. Alternatively, you can delete just the local cache
         with the ``--cache-only`` option, or keep the security info with the
         ``--keep-security-info`` option.
 
+        Always first use ``--dry-run --list`` to see what would be deleted.
+        """)
+        subparser = subparsers.add_parser('rdelete', parents=[common_parser], add_help=False,
+                                          description=self.do_rdelete.__doc__,
+                                          epilog=rdelete_epilog,
+                                          formatter_class=argparse.RawDescriptionHelpFormatter,
+                                          help='delete repository')
+        subparser.set_defaults(func=self.do_rdelete)
+        subparser.add_argument('-n', '--dry-run', dest='dry_run', action='store_true',
+                               help='do not change repository')
+        subparser.add_argument('--list', dest='output_list', action='store_true',
+                               help='output verbose list of archives')
+        subparser.add_argument('--force', dest='forced', action='count', default=0,
+                               help='force deletion of corrupted archives, '
+                                    'use ``--force --force`` in case ``--force`` does not work.')
+        subparser.add_argument('--cache-only', dest='cache_only', action='store_true',
+                               help='delete only the local cache for the given repository')
+        subparser.add_argument('--keep-security-info', dest='keep_security_info', action='store_true',
+                               help='keep the local security info when deleting a repository')
+
+        # borg delete
+        delete_epilog = process_epilog("""
+        This command deletes archives from the repository.
+
+        Important: When deleting archives, repository disk space is **not** freed until
+        you run ``borg compact``.
+
         When in doubt, use ``--dry-run --list`` to see what would be deleted.
 
         When using ``--stats``, you will get some statistics about how much data was
@@ -4087,9 +4096,7 @@ class Archiver:
         (for more info on these patterns, see :ref:`borg_patterns`). Note that these
         two options are mutually exclusive.
 
-        To avoid accidentally deleting archives, especially when using glob patterns,
-        it might be helpful to use the ``--dry-run`` to test out the command without
-        actually making any changes to the repository.
+        Always first use ``--dry-run --list`` to see what would be deleted.
         """)
         subparser = subparsers.add_parser('delete', parents=[common_parser], add_help=False,
                                           description=self.do_delete.__doc__,
@@ -4101,6 +4108,8 @@ class Archiver:
                                help='do not change repository')
         subparser.add_argument('--list', dest='output_list', action='store_true',
                                help='output verbose list of archives')
+        subparser.add_argument('--consider-checkpoints', action='store_true', dest='consider_checkpoints',
+                               help='consider checkpoint archives for deletion (default: not considered).')
         subparser.add_argument('-s', '--stats', dest='stats', action='store_true',
                                help='print statistics for the deleted archive')
         subparser.add_argument('--cache-only', dest='cache_only', action='store_true',
@@ -4112,10 +4121,6 @@ class Archiver:
                                help='keep the local security info when deleting a repository')
         subparser.add_argument('--save-space', dest='save_space', action='store_true',
                                help='work slower, but using less space')
-        subparser.add_argument('--name', dest='name', metavar='NAME', type=NameSpec,
-                               help='specify the archive name')
-        subparser.add_argument('archives', metavar='ARCHIVE', nargs='*',
-                               help='archives to delete')
         define_archive_filters_group(subparser)
 
         # borg transfer
diff --git a/src/borg/testsuite/archiver.py b/src/borg/testsuite/archiver.py
index c5b5c10a5..11587efef 100644
--- a/src/borg/testsuite/archiver.py
+++ b/src/borg/testsuite/archiver.py
@@ -710,7 +710,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=none')
         self._set_repository_id(self.repository_path, repository_id)
         self.assert_equal(repository_id, self._extract_repository_id(self.repository_path))
-        self.cmd(f'--repo={self.repository_location}', 'delete', '--cache-only')
+        self.cmd(f'--repo={self.repository_location}', 'rdelete', '--cache-only')
         if self.FORK_DEFAULT:
             self.cmd(f'--repo={self.repository_location}', 'create', 'test.2', 'input', exit_code=EXIT_ERROR)
         else:
@@ -723,8 +723,8 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         os.environ['BORG_PASSPHRASE'] = 'passphrase'
         self.cmd(f'--repo={self.repository_location}_encrypted', 'init', '--encryption=repokey')
         self.cmd(f'--repo={self.repository_location}_encrypted', 'create', 'test', 'input')
-        self.cmd(f'--repo={self.repository_location}_unencrypted', 'delete', '--cache-only')
-        self.cmd(f'--repo={self.repository_location}_encrypted', 'delete', '--cache-only')
+        self.cmd(f'--repo={self.repository_location}_unencrypted', 'rdelete', '--cache-only')
+        self.cmd(f'--repo={self.repository_location}_encrypted', 'rdelete', '--cache-only')
         shutil.rmtree(self.repository_path + '_encrypted')
         os.rename(self.repository_path + '_unencrypted', self.repository_path + '_encrypted')
         if self.FORK_DEFAULT:
@@ -744,7 +744,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         with environment_variable(BORG_PASSPHRASE=''):
             self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
             # Delete cache & security database, AKA switch to user perspective
-            self.cmd(f'--repo={self.repository_location}', 'delete', '--cache-only')
+            self.cmd(f'--repo={self.repository_location}', 'rdelete', '--cache-only')
             shutil.rmtree(self.get_security_dir())
         with environment_variable(BORG_PASSPHRASE=None):
             # This is the part were the user would be tricked, e.g. she assumes that BORG_PASSPHRASE
@@ -1276,7 +1276,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
     def test_create_no_cache_sync(self):
         self.create_test_files()
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
-        self.cmd(f'--repo={self.repository_location}', 'delete', '--cache-only')
+        self.cmd(f'--repo={self.repository_location}', 'rdelete', '--cache-only')
         create_json = json.loads(self.cmd(f'--repo={self.repository_location}', 'create',
                                           '--no-cache-sync', '--json', '--error',
                                           'test', 'input'))  # ignore experimental warning
@@ -1284,7 +1284,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         create_stats = create_json['cache']['stats']
         info_stats = info_json['cache']['stats']
         assert create_stats == info_stats
-        self.cmd(f'--repo={self.repository_location}', 'delete', '--cache-only')
+        self.cmd(f'--repo={self.repository_location}', 'rdelete', '--cache-only')
         self.cmd(f'--repo={self.repository_location}', 'create', '--no-cache-sync', 'test2', 'input')
         self.cmd(f'--repo={self.repository_location}', 'rinfo')
         self.cmd(f'--repo={self.repository_location}', 'check')
@@ -1601,9 +1601,9 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self.cmd(f'--repo={self.repository_location}', 'extract', 'test.2', '--dry-run')
         self.cmd(f'--repo={self.repository_location}', 'delete', '--prefix', 'another_')
         self.cmd(f'--repo={self.repository_location}', 'delete', '--last', '1')
-        self.cmd(f'--repo={self.repository_location}', 'delete', '--name=test')
+        self.cmd(f'--repo={self.repository_location}', 'delete', '-a', 'test')
         self.cmd(f'--repo={self.repository_location}', 'extract', 'test.2', '--dry-run')
-        output = self.cmd(f'--repo={self.repository_location}', 'delete', '--name=test.2', '--stats')
+        output = self.cmd(f'--repo={self.repository_location}', 'delete', '-a', 'test.2', '--stats')
         self.assert_in('Deleted data:', output)
         # Make sure all data except the manifest has been deleted
         with Repository(self.repository_path) as repository:
@@ -1615,9 +1615,10 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self.cmd(f'--repo={self.repository_location}', 'create', 'test1', 'input')
         self.cmd(f'--repo={self.repository_location}', 'create', 'test2', 'input')
         self.cmd(f'--repo={self.repository_location}', 'create', 'test3', 'input')
-        self.cmd(f'--repo={self.repository_location}', 'delete', '--name=test1', 'test2')
+        self.cmd(f'--repo={self.repository_location}', 'delete', '-a', 'test1')
+        self.cmd(f'--repo={self.repository_location}', 'delete', '-a', 'test2')
         self.cmd(f'--repo={self.repository_location}', 'extract', 'test3', '--dry-run')
-        self.cmd(f'--repo={self.repository_location}', 'delete', '--name=test3')
+        self.cmd(f'--repo={self.repository_location}', 'delete', '-a', 'test3')
         assert not self.cmd(f'--repo={self.repository_location}', 'rlist')
 
     def test_delete_repo(self):
@@ -1627,10 +1628,10 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
         self.cmd(f'--repo={self.repository_location}', 'create', 'test.2', 'input')
         os.environ['BORG_DELETE_I_KNOW_WHAT_I_AM_DOING'] = 'no'
-        self.cmd(f'--repo={self.repository_location}', 'delete', exit_code=2)
+        self.cmd(f'--repo={self.repository_location}', 'rdelete', exit_code=2)
         assert os.path.exists(self.repository_path)
         os.environ['BORG_DELETE_I_KNOW_WHAT_I_AM_DOING'] = 'YES'
-        self.cmd(f'--repo={self.repository_location}', 'delete')
+        self.cmd(f'--repo={self.repository_location}', 'rdelete')
         # Make sure the repo is gone
         self.assertFalse(os.path.exists(self.repository_path))
 
@@ -1647,7 +1648,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
             else:
                 assert False  # missed the file
             repository.commit(compact=False)
-        output = self.cmd(f'--repo={self.repository_location}', 'delete', '--name=test', '--force')
+        output = self.cmd(f'--repo={self.repository_location}', 'delete', '-a', 'test', '--force')
         self.assert_in('deleted archive was corrupted', output)
         self.cmd(f'--repo={self.repository_location}', 'check', '--repair')
         output = self.cmd(f'--repo={self.repository_location}', 'rlist')
@@ -1662,7 +1663,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
             id = archive.metadata.items[0]
             repository.put(id, b'corrupted items metadata stream chunk')
             repository.commit(compact=False)
-        self.cmd(f'--repo={self.repository_location}', 'delete', '--name=test', '--force', '--force')
+        self.cmd(f'--repo={self.repository_location}', 'delete', '-a', 'test', '--force', '--force')
         self.cmd(f'--repo={self.repository_location}', 'check', '--repair')
         output = self.cmd(f'--repo={self.repository_location}', 'rlist')
         self.assert_not_in('test', output)
@@ -1831,7 +1832,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
 
     def test_unknown_feature_on_cache_sync(self):
         self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
-        self.cmd(f'--repo={self.repository_location}', 'delete', '--cache-only')
+        self.cmd(f'--repo={self.repository_location}', 'rdelete', '--cache-only')
         self.add_unknown_feature(Manifest.Operation.READ)
         self.cmd_raises_unknown_feature([f'--repo={self.repository_location}', 'create', 'test', 'input'])
 
@@ -1861,10 +1862,10 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
         self.add_unknown_feature(Manifest.Operation.DELETE)
         # delete of an archive raises
-        self.cmd_raises_unknown_feature([f'--repo={self.repository_location}', 'delete', '--name=test'])
+        self.cmd_raises_unknown_feature([f'--repo={self.repository_location}', 'delete', '-a', 'test'])
         self.cmd_raises_unknown_feature([f'--repo={self.repository_location}', 'prune', '--keep-daily=3'])
         # delete of the whole repository ignores features
-        self.cmd(f'--repo={self.repository_location}', 'delete')
+        self.cmd(f'--repo={self.repository_location}', 'rdelete')
 
     @unittest.skipUnless(llfuse, 'llfuse not installed')
     def test_unknown_feature_on_mount(self):
@@ -2784,7 +2785,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         verify_uniqueness()
         self.cmd(f'--repo={self.repository_location}', 'create', 'test.2', 'input')
         verify_uniqueness()
-        self.cmd(f'--repo={self.repository_location}', 'delete', '--name=test.2')
+        self.cmd(f'--repo={self.repository_location}', 'delete', '-a', 'test.2')
         verify_uniqueness()
 
     def test_aes_counter_uniqueness_keyfile(self):
@@ -4042,7 +4043,7 @@ class ArchiverCorruptionTestCase(ArchiverTestCaseBase):
         self.cmd(f'--repo={self.repository_location}', 'create', 'test2', 'input')
 
         # Force cache sync, creating archive chunks of test1 and test2 in chunks.archive.d
-        self.cmd(f'--repo={self.repository_location}', 'delete', '--cache-only')
+        self.cmd(f'--repo={self.repository_location}', 'rdelete', '--cache-only')
         self.cmd(f'--repo={self.repository_location}', 'rinfo', '--json')
 
         chunks_archive = os.path.join(self.cache_path, 'chunks.archive.d')

From d00d650d8862d4ddf89b60f171be97174e461af7 Mon Sep 17 00:00:00 2001
From: Thomas Waldmann <tw@waldmann-edv.de>
Date: Thu, 23 Jun 2022 09:16:29 +0200
Subject: [PATCH 066/160] borg init -> borg rcreate

this is to complement borg rdelete, see also borg create / delete.
---
 setup_docs.py                   |   2 +-
 src/borg/archiver.py            |  20 +-
 src/borg/testsuite/archiver.py  | 408 ++++++++++++++++----------------
 src/borg/testsuite/benchmark.py |   2 +-
 4 files changed, 216 insertions(+), 216 deletions(-)

diff --git a/setup_docs.py b/setup_docs.py
index 056c23213..2f9dcb35d 100644
--- a/setup_docs.py
+++ b/setup_docs.py
@@ -280,7 +280,7 @@ class build_man(Command):
         'recreate': ('patterns', 'placeholders', 'compression'),
         'list': ('info', 'diff', 'prune', 'patterns'),
         'info': ('list', 'diff'),
-        'init': ('create', 'delete', 'check', 'list', 'key-import', 'key-export', 'key-change-passphrase'),
+        'rcreate': ('rdelete', 'rlist', 'check', 'key-import', 'key-export', 'key-change-passphrase'),
         'key-import': ('key-export', ),
         'key-export': ('key-import', ),
         'mount': ('umount', 'extract'),  # Would be cooler if these two were on the same page
diff --git a/src/borg/archiver.py b/src/borg/archiver.py
index 436aa8ddc..3273e8cb5 100644
--- a/src/borg/archiver.py
+++ b/src/borg/archiver.py
@@ -472,8 +472,8 @@ class Archiver:
 
     @with_repository(create=True, exclusive=True, manifest=False)
     @with_other_repository(key=True, compatibility=(Manifest.Operation.READ, ))
-    def do_init(self, args, repository, *, other_repository=None, other_key=None):
-        """Initialize an empty repository"""
+    def do_rcreate(self, args, repository, *, other_repository=None, other_key=None):
+        """Create a new, empty repository"""
         path = args.location.canonical_path()
         logger.info('Initializing repository at "%s"' % path)
         try:
@@ -4383,9 +4383,9 @@ class Archiver:
                                help='format output as JSON')
         define_archive_filters_group(subparser)
 
-        # borg init
-        init_epilog = process_epilog("""
-        This command initializes an empty repository. A repository is a filesystem
+        # borg rcreate
+        rcreate_epilog = process_epilog("""
+        This command creates a new, empty repository. A repository is a filesystem
         directory containing the deduplicated data from zero or more archives.
 
         Encryption mode TLDR
@@ -4398,7 +4398,7 @@ class Archiver:
 
         ::
 
-            borg init --encryption repokey /path/to/repo
+            borg rcreate --encryption repokey /path/to/repo
 
         Borg will:
 
@@ -4507,11 +4507,11 @@ class Archiver:
         Neither is inherently linked to the key derivation function, but since we were going
         to break backwards compatibility anyway we took the opportunity to fix all 3 issues at once.
         """)
-        subparser = subparsers.add_parser('init', parents=[common_parser], add_help=False,
-                                          description=self.do_init.__doc__, epilog=init_epilog,
+        subparser = subparsers.add_parser('rcreate', parents=[common_parser], add_help=False,
+                                          description=self.do_rcreate.__doc__, epilog=rcreate_epilog,
                                           formatter_class=argparse.RawDescriptionHelpFormatter,
-                                          help='initialize empty repository')
-        subparser.set_defaults(func=self.do_init)
+                                          help='create a new, empty repository')
+        subparser.set_defaults(func=self.do_rcreate)
         subparser.add_argument('--other-repo', metavar='SRC_REPOSITORY', dest='other_location',
                                type=location_validator(other=True), default=Location(other=True),
                                help='reuse the key material from the other repository')
diff --git a/src/borg/testsuite/archiver.py b/src/borg/testsuite/archiver.py
index 11587efef..ef22bf58b 100644
--- a/src/borg/testsuite/archiver.py
+++ b/src/borg/testsuite/archiver.py
@@ -147,7 +147,7 @@ def test_return_codes(cmd, tmpdir):
     input = tmpdir.mkdir('input')
     output = tmpdir.mkdir('output')
     input.join('test_file').write('content')
-    rc, out = cmd('--repo=%s' % str(repo), 'init', '--encryption=none')
+    rc, out = cmd('--repo=%s' % str(repo), 'rcreate', '--encryption=none')
     assert rc == EXIT_SUCCESS
     rc, out = cmd('--repo=%s' % repo, 'create', 'archive', str(input))
     assert rc == EXIT_SUCCESS
@@ -203,9 +203,9 @@ def test_disk_full(cmd):
             shutil.rmtree(input, ignore_errors=True)
             # keep some space and some inodes in reserve that we can free up later:
             make_files(reserve, 80, 100000, rnd=False)
-            rc, out = cmd(f'--repo={repo}', 'init')
+            rc, out = cmd(f'--repo={repo}', 'rcreate')
             if rc != EXIT_SUCCESS:
-                print('init', rc, out)
+                print('rcreate', rc, out)
             assert rc == EXIT_SUCCESS
             try:
                 success, i = True, 0
@@ -391,7 +391,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
     def test_basic_functionality(self):
         have_root = self.create_test_files()
         # fork required to test show-rc output
-        output = self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey', '--show-version', '--show-rc', fork=True)
+        output = self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey', '--show-version', '--show-rc', fork=True)
         self.assert_in('borgbackup version', output)
         self.assert_in('terminating with success status, rc 0', output)
         self.cmd(f'--repo={self.repository_location}', 'create', '--exclude-nodump', 'test', 'input')
@@ -462,7 +462,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         hl_b = os.path.join(path_b, 'hardlink')
         self.create_regular_file(hl_a, contents=b'123456')
         os.link(hl_a, hl_b)
-        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=none')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=none')
         self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input', 'input')  # give input twice!
         # test if created archive has 'input' contents twice:
         archive_list = self.cmd(f'--repo={self.repository_location}', 'list', 'test', '--json-lines')
@@ -476,13 +476,13 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         repository_location = self.prefix + repository_path
         with pytest.raises(Repository.ParentPathDoesNotExist):
             # normal borg init does NOT create missing parent dirs
-            self.cmd(f'--repo={repository_location}', 'init', '--encryption=none')
+            self.cmd(f'--repo={repository_location}', 'rcreate', '--encryption=none')
         # but if told so, it does:
-        self.cmd(f'--repo={repository_location}', 'init', '--encryption=none', '--make-parent-dirs')
+        self.cmd(f'--repo={repository_location}', 'rcreate', '--encryption=none', '--make-parent-dirs')
         assert os.path.exists(parent_path)
 
     def test_unix_socket(self):
-        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
         try:
             sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
             sock.bind(os.path.join(self.input_path, 'unix-socket'))
@@ -500,7 +500,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
     @pytest.mark.skipif(not are_symlinks_supported(), reason='symlinks not supported')
     def test_symlink_extract(self):
         self.create_test_files()
-        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
         self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
         with changedir('output'):
             self.cmd(f'--repo={self.repository_location}', 'extract', 'test')
@@ -513,7 +513,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         with changedir('input'):
             os.symlink('target', 'symlink1')
             os.link('symlink1', 'symlink2', follow_symlinks=False)
-        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
         self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
         with changedir('output'):
             output = self.cmd(f'--repo={self.repository_location}', 'extract', 'test')
@@ -547,7 +547,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         atime, mtime = 123456780, 234567890
         have_noatime = has_noatime('input/file1')
         os.utime('input/file1', (atime, mtime))
-        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
         self.cmd(f'--repo={self.repository_location}', 'create', '--atime', 'test', 'input')
         with changedir('output'):
             self.cmd(f'--repo={self.repository_location}', 'extract', 'test')
@@ -567,7 +567,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         birthtime, mtime, atime = 946598400, 946684800, 946771200
         os.utime('input/file1', (atime, birthtime))
         os.utime('input/file1', (atime, mtime))
-        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
         self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
         with changedir('output'):
             self.cmd(f'--repo={self.repository_location}', 'extract', 'test')
@@ -583,7 +583,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         birthtime, mtime, atime = 946598400, 946684800, 946771200
         os.utime('input/file1', (atime, birthtime))
         os.utime('input/file1', (atime, mtime))
-        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
         self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input', '--nobirthtime')
         with changedir('output'):
             self.cmd(f'--repo={self.repository_location}', 'extract', 'test')
@@ -644,7 +644,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         if sparse_support:
             # we could create a sparse input file, so creating a backup of it and
             # extracting it again (as sparse) should also work:
-            self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+            self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
             self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
             with changedir(self.output_path):
                 self.cmd(f'--repo={self.repository_location}', 'extract', 'test', '--sparse')
@@ -663,7 +663,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
             filename = os.path.join(self.input_path, filename)
             with open(filename, 'wb'):
                 pass
-        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
         self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
         for filename in filenames:
             with changedir('output'):
@@ -673,11 +673,11 @@ class ArchiverTestCase(ArchiverTestCaseBase):
     def test_repository_swap_detection(self):
         self.create_test_files()
         os.environ['BORG_PASSPHRASE'] = 'passphrase'
-        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
         repository_id = self._extract_repository_id(self.repository_path)
         self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
         shutil.rmtree(self.repository_path)
-        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=none')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=none')
         self._set_repository_id(self.repository_path, repository_id)
         self.assert_equal(repository_id, self._extract_repository_id(self.repository_path))
         if self.FORK_DEFAULT:
@@ -688,9 +688,9 @@ class ArchiverTestCase(ArchiverTestCaseBase):
 
     def test_repository_swap_detection2(self):
         self.create_test_files()
-        self.cmd(f'--repo={self.repository_location}_unencrypted', 'init', '--encryption=none')
+        self.cmd(f'--repo={self.repository_location}_unencrypted', 'rcreate', '--encryption=none')
         os.environ['BORG_PASSPHRASE'] = 'passphrase'
-        self.cmd(f'--repo={self.repository_location}_encrypted', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}_encrypted', 'rcreate', '--encryption=repokey')
         self.cmd(f'--repo={self.repository_location}_encrypted', 'create', 'test', 'input')
         shutil.rmtree(self.repository_path + '_encrypted')
         os.rename(self.repository_path + '_unencrypted', self.repository_path + '_encrypted')
@@ -703,11 +703,11 @@ class ArchiverTestCase(ArchiverTestCaseBase):
     def test_repository_swap_detection_no_cache(self):
         self.create_test_files()
         os.environ['BORG_PASSPHRASE'] = 'passphrase'
-        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
         repository_id = self._extract_repository_id(self.repository_path)
         self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
         shutil.rmtree(self.repository_path)
-        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=none')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=none')
         self._set_repository_id(self.repository_path, repository_id)
         self.assert_equal(repository_id, self._extract_repository_id(self.repository_path))
         self.cmd(f'--repo={self.repository_location}', 'rdelete', '--cache-only')
@@ -719,9 +719,9 @@ class ArchiverTestCase(ArchiverTestCaseBase):
 
     def test_repository_swap_detection2_no_cache(self):
         self.create_test_files()
-        self.cmd(f'--repo={self.repository_location}_unencrypted', 'init', '--encryption=none')
+        self.cmd(f'--repo={self.repository_location}_unencrypted', 'rcreate', '--encryption=none')
         os.environ['BORG_PASSPHRASE'] = 'passphrase'
-        self.cmd(f'--repo={self.repository_location}_encrypted', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}_encrypted', 'rcreate', '--encryption=repokey')
         self.cmd(f'--repo={self.repository_location}_encrypted', 'create', 'test', 'input')
         self.cmd(f'--repo={self.repository_location}_unencrypted', 'rdelete', '--cache-only')
         self.cmd(f'--repo={self.repository_location}_encrypted', 'rdelete', '--cache-only')
@@ -737,12 +737,12 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         # Check that a repokey repo with a blank passphrase is considered like a plaintext repo.
         self.create_test_files()
         # User initializes her repository with her passphrase
-        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
         self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
         # Attacker replaces it with her own repository, which is encrypted but has no passphrase set
         shutil.rmtree(self.repository_path)
         with environment_variable(BORG_PASSPHRASE=''):
-            self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+            self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
             # Delete cache & security database, AKA switch to user perspective
             self.cmd(f'--repo={self.repository_location}', 'rdelete', '--cache-only')
             shutil.rmtree(self.get_security_dir())
@@ -757,7 +757,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
                     self.cmd(f'--repo={self.repository_location}', 'create', 'test.2', 'input')
 
     def test_repository_move(self):
-        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
         security_dir = self.get_security_dir()
         os.rename(self.repository_path, self.repository_path + '_new')
         with environment_variable(BORG_RELOCATED_REPO_ACCESS_IS_OK='yes'):
@@ -775,7 +775,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
             assert os.path.exists(os.path.join(security_dir, file))
 
     def test_security_dir_compat(self):
-        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
         with open(os.path.join(self.get_security_dir(), 'location'), 'w') as fd:
             fd.write('something outdated')
         # This is fine, because the cache still has the correct information. security_dir and cache can disagree
@@ -783,7 +783,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self.cmd(f'--repo={self.repository_location}', 'rinfo')
 
     def test_unknown_unencrypted(self):
-        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=none')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=none')
         # Ok: repository is known
         self.cmd(f'--repo={self.repository_location}', 'rinfo')
 
@@ -803,7 +803,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
             self.cmd(f'--repo={self.repository_location}', 'rinfo')
 
     def test_strip_components(self):
-        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
         self.create_regular_file('dir/file')
         self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
         with changedir('output'):
@@ -832,7 +832,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         os.link(os.path.join(self.input_path, 'dir1/source2'),
                 os.path.join(self.input_path, 'dir1/aaaa'))
 
-        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
         self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
 
     @requires_hardlinks
@@ -909,7 +909,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         hl_b = os.path.join(path_b, 'hardlink')
         self.create_regular_file(hl_a, contents=b'123456')
         os.link(hl_a, hl_b)
-        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=none')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=none')
         self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input', 'input')  # give input twice!
         # now test extraction
         with changedir('output'):
@@ -922,7 +922,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
             assert os.stat('input/b/hardlink').st_nlink == 2
 
     def test_extract_include_exclude(self):
-        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
         self.create_regular_file('file1', size=1024 * 80)
         self.create_regular_file('file2', size=1024 * 80)
         self.create_regular_file('file3', size=1024 * 80)
@@ -939,7 +939,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self.assert_equal(sorted(os.listdir('output/input')), ['file1', 'file3'])
 
     def test_extract_include_exclude_regex(self):
-        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
         self.create_regular_file('file1', size=1024 * 80)
         self.create_regular_file('file2', size=1024 * 80)
         self.create_regular_file('file3', size=1024 * 80)
@@ -972,7 +972,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self.assert_equal(sorted(os.listdir('output/input')), ['file3'])
 
     def test_extract_include_exclude_regex_from_file(self):
-        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
         self.create_regular_file('file1', size=1024 * 80)
         self.create_regular_file('file2', size=1024 * 80)
         self.create_regular_file('file3', size=1024 * 80)
@@ -1012,7 +1012,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self.assert_equal(sorted(os.listdir('output/input')), ['file3'])
 
     def test_extract_with_pattern(self):
-        self.cmd(f'--repo={self.repository_location}', "init", '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
         self.create_regular_file("file1", size=1024 * 80)
         self.create_regular_file("file2", size=1024 * 80)
         self.create_regular_file("file3", size=1024 * 80)
@@ -1045,7 +1045,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self.assert_equal(sorted(os.listdir("output/input")), ["file1", "file2", "file333"])
 
     def test_extract_list_output(self):
-        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
         self.create_regular_file('file', size=1024 * 80)
 
         self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
@@ -1070,7 +1070,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self.assert_in("input/file", output)
 
     def test_extract_progress(self):
-        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
         self.create_regular_file('file', size=1024 * 80)
         self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
 
@@ -1079,7 +1079,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
             assert 'Extracting:' in output
 
     def _create_test_caches(self):
-        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
         self.create_regular_file('file1', size=1024 * 80)
         self.create_regular_file('cache1/%s' % CACHE_TAG_NAME,
                                  contents=CACHE_TAG_CONTENTS + b' extra stuff')
@@ -1093,7 +1093,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
                                      contents=CACHE_TAG_CONTENTS + b' extra stuff')
 
     def test_create_stdin(self):
-        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
         input_data = b'\x00foo\n\nbar\n   \n'
         self.cmd(f'--repo={self.repository_location}', 'create', 'test', '-', input=input_data)
         item = json.loads(self.cmd(f'--repo={self.repository_location}', 'list', 'test', '--json-lines'))
@@ -1105,7 +1105,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         assert extracted_data == input_data
 
     def test_create_content_from_command(self):
-        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
         input_data = 'some test content'
         name = 'a/b/c'
         self.cmd(f'--repo={self.repository_location}', 'create', '--stdin-name', name, '--content-from-command',
@@ -1119,7 +1119,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         assert extracted_data == input_data + '\n'
 
     def test_create_content_from_command_with_failed_command(self):
-        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
         output = self.cmd(f'--repo={self.repository_location}', 'create', '--content-from-command', 'test',
                           '--', 'sh', '-c', 'exit 73;', exit_code=2)
         assert output.endswith("Command 'sh' exited with status 73\n")
@@ -1127,12 +1127,12 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         assert archive_list['archives'] == []
 
     def test_create_content_from_command_missing_command(self):
-        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
         output = self.cmd(f'--repo={self.repository_location}', 'create', 'test', '--content-from-command', exit_code=2)
         assert output.endswith('No command given.\n')
 
     def test_create_paths_from_stdin(self):
-        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
         self.create_regular_file("file1", size=1024 * 80)
         self.create_regular_file("dir1/file2", size=1024 * 80)
         self.create_regular_file("dir1/file3", size=1024 * 80)
@@ -1146,7 +1146,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         assert paths == ['input/file1', 'input/dir1', 'input/file4']
 
     def test_create_paths_from_command(self):
-        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
         self.create_regular_file("file1", size=1024 * 80)
         self.create_regular_file("file2", size=1024 * 80)
         self.create_regular_file("file3", size=1024 * 80)
@@ -1160,7 +1160,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         assert paths == ['input/file1', 'input/file2', 'input/file3']
 
     def test_create_paths_from_command_with_failed_command(self):
-        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
         output = self.cmd(f'--repo={self.repository_location}', 'create', '--paths-from-command', 'test',
                           '--', 'sh', '-c', 'exit 73;', exit_code=2)
         assert output.endswith("Command 'sh' exited with status 73\n")
@@ -1168,18 +1168,18 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         assert archive_list['archives'] == []
 
     def test_create_paths_from_command_missing_command(self):
-        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
         output = self.cmd(f'--repo={self.repository_location}', 'create', 'test', '--paths-from-command', exit_code=2)
         assert output.endswith('No command given.\n')
 
     def test_create_without_root(self):
         """test create without a root"""
-        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
         self.cmd(f'--repo={self.repository_location}', 'create', 'test', exit_code=2)
 
     def test_create_pattern_root(self):
         """test create with only a root pattern"""
-        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
         self.create_regular_file('file1', size=1024 * 80)
         self.create_regular_file('file2', size=1024 * 80)
         output = self.cmd(f'--repo={self.repository_location}', 'create', 'test', '-v', '--list', '--pattern=R input')
@@ -1188,7 +1188,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
 
     def test_create_pattern(self):
         """test file patterns during create"""
-        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
         self.create_regular_file('file1', size=1024 * 80)
         self.create_regular_file('file2', size=1024 * 80)
         self.create_regular_file('file_important', size=1024 * 80)
@@ -1201,7 +1201,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
 
     def test_create_pattern_file(self):
         """test file patterns during create"""
-        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
         self.create_regular_file('file1', size=1024 * 80)
         self.create_regular_file('file2', size=1024 * 80)
         self.create_regular_file('otherfile', size=1024 * 80)
@@ -1220,7 +1220,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         with open(self.patterns_file_path2, 'wb') as fd:
             fd.write(b'+ input/x/b\n- input/x*\n')
 
-        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
         self.create_regular_file('x/a/foo_a', size=1024 * 80)
         self.create_regular_file('x/b/foo_b', size=1024 * 80)
         self.create_regular_file('y/foo_y', size=1024 * 80)
@@ -1237,7 +1237,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         with open(self.patterns_file_path2, 'wb') as fd:
             fd.write(b'+ input/x/b\n! input/x*\n')
 
-        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
         self.create_regular_file('x/a/foo_a', size=1024 * 80)
         self.create_regular_file('x/b/foo_b', size=1024 * 80)
         self.create_regular_file('y/foo_y', size=1024 * 80)
@@ -1254,7 +1254,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         with open(self.patterns_file_path2, 'wb') as fd:
             fd.write(b'+ input/x/a\n+ input/x/b\n- input/x*\n')
 
-        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
 
         self.create_regular_file('x/a/foo_a', size=1024 * 80)
         self.create_regular_file('x/b/foo_b', size=1024 * 80)
@@ -1275,7 +1275,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
 
     def test_create_no_cache_sync(self):
         self.create_test_files()
-        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
         self.cmd(f'--repo={self.repository_location}', 'rdelete', '--cache-only')
         create_json = json.loads(self.cmd(f'--repo={self.repository_location}', 'create',
                                           '--no-cache-sync', '--json', '--error',
@@ -1290,7 +1290,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self.cmd(f'--repo={self.repository_location}', 'check')
 
     def test_extract_pattern_opt(self):
-        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
         self.create_regular_file('file1', size=1024 * 80)
         self.create_regular_file('file2', size=1024 * 80)
         self.create_regular_file('file_important', size=1024 * 80)
@@ -1318,7 +1318,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self._assert_test_caches()
 
     def _create_test_tagged(self):
-        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
         self.create_regular_file('file1', size=1024 * 80)
         self.create_regular_file('tagged1/.NOBACKUP')
         self.create_regular_file('tagged2/00-NOBACKUP')
@@ -1343,7 +1343,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self._assert_test_tagged()
 
     def _create_test_keep_tagged(self):
-        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
         self.create_regular_file('file0', size=1024)
         self.create_regular_file('tagged1/.NOBACKUP1')
         self.create_regular_file('tagged1/file1', size=1024)
@@ -1383,7 +1383,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
 
     @pytest.mark.skipif(not are_hardlinks_supported(), reason='hardlinks not supported')
     def test_recreate_hardlinked_tags(self):  # test for issue #4911
-        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=none')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=none')
         self.create_regular_file('file1', contents=CACHE_TAG_CONTENTS)  # "wrong" filename, but correct tag contents
         os.mkdir(os.path.join(self.input_path, 'subdir'))  # to make sure the tag is encountered *after* file1
         os.link(os.path.join(self.input_path, 'file1'),
@@ -1409,7 +1409,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         capabilities = b'\x01\x00\x00\x02\x00 \x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
         self.create_regular_file('file')
         xattr.setxattr(b'input/file', b'security.capability', capabilities)
-        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
         self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
         with changedir('output'):
             with patch.object(os, 'fchown', patched_fchown):
@@ -1430,7 +1430,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
 
         self.create_regular_file('file')
         xattr.setxattr(b'input/file', b'user.attribute', b'value')
-        self.cmd(f'--repo={self.repository_location}', 'init', '-e' 'none')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', '-e' 'none')
         self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
         with changedir('output'):
             input_abspath = os.path.abspath('input/file')
@@ -1448,7 +1448,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
             assert os.path.isfile(input_abspath)
 
     def test_path_normalization(self):
-        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
         self.create_regular_file('dir1/dir2/file', size=1024 * 80)
         with changedir('input/dir1/dir2'):
             self.cmd(f'--repo={self.repository_location}', 'create', 'test',
@@ -1458,7 +1458,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self.assert_in(' input/dir1/dir2/file', output)
 
     def test_exclude_normalization(self):
-        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
         self.create_regular_file('file1', size=1024 * 80)
         self.create_regular_file('file2', size=1024 * 80)
         with changedir('input'):
@@ -1478,13 +1478,13 @@ class ArchiverTestCase(ArchiverTestCaseBase):
 
     def test_repeated_files(self):
         self.create_regular_file('file1', size=1024 * 80)
-        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
         self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input', 'input')
 
     def test_overwrite(self):
         self.create_regular_file('file1', size=1024 * 80)
         self.create_regular_file('dir2/file2', size=1024 * 80)
-        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
         self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
         # Overwriting regular files and directories should be supported
         os.mkdir('output/input')
@@ -1503,7 +1503,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
     def test_rename(self):
         self.create_regular_file('file1', size=1024 * 80)
         self.create_regular_file('dir2/file2', size=1024 * 80)
-        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
         self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
         self.cmd(f'--repo={self.repository_location}', 'create', 'test.2', 'input')
         self.cmd(f'--repo={self.repository_location}', 'extract', 'test', '--dry-run')
@@ -1522,7 +1522,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
 
     def test_info(self):
         self.create_regular_file('file1', size=1024 * 80)
-        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
         self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
         info_repo = self.cmd(f'--repo={self.repository_location}', 'rinfo')
         assert 'All archives:' in info_repo
@@ -1533,7 +1533,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
 
     def test_info_json(self):
         self.create_regular_file('file1', size=1024 * 80)
-        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
         self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
         info_repo = json.loads(self.cmd(f'--repo={self.repository_location}', 'rinfo', '--json'))
         repository = info_repo['repository']
@@ -1563,7 +1563,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
 
     def test_info_json_of_empty_archive(self):
         """See https://github.com/borgbackup/borg/issues/6120"""
-        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
         info_repo = json.loads(self.cmd(f'--repo={self.repository_location}', 'info', '--json', '--first=1'))
         assert info_repo["archives"] == []
         info_repo = json.loads(self.cmd(f'--repo={self.repository_location}', 'info', '--json', '--last=1'))
@@ -1571,7 +1571,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
 
     def test_comment(self):
         self.create_regular_file('file1', size=1024 * 80)
-        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
         self.cmd(f'--repo={self.repository_location}', 'create', 'test1', 'input')
         self.cmd(f'--repo={self.repository_location}', 'create', 'test2', 'input', '--comment', 'this is the comment')
         self.cmd(f'--repo={self.repository_location}', 'create', 'test3', 'input', '--comment', '"deleted" comment')
@@ -1591,7 +1591,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
     def test_delete(self):
         self.create_regular_file('file1', size=1024 * 80)
         self.create_regular_file('dir2/file2', size=1024 * 80)
-        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
         self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
         self.cmd(f'--repo={self.repository_location}', 'create', 'test.2', 'input')
         self.cmd(f'--repo={self.repository_location}', 'create', 'test.3', 'input')
@@ -1611,7 +1611,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
 
     def test_delete_multiple(self):
         self.create_regular_file('file1', size=1024 * 80)
-        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
         self.cmd(f'--repo={self.repository_location}', 'create', 'test1', 'input')
         self.cmd(f'--repo={self.repository_location}', 'create', 'test2', 'input')
         self.cmd(f'--repo={self.repository_location}', 'create', 'test3', 'input')
@@ -1624,7 +1624,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
     def test_delete_repo(self):
         self.create_regular_file('file1', size=1024 * 80)
         self.create_regular_file('dir2/file2', size=1024 * 80)
-        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
         self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
         self.cmd(f'--repo={self.repository_location}', 'create', 'test.2', 'input')
         os.environ['BORG_DELETE_I_KNOW_WHAT_I_AM_DOING'] = 'no'
@@ -1636,7 +1636,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self.assertFalse(os.path.exists(self.repository_path))
 
     def test_delete_force(self):
-        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=none')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=none')
         self.create_src_archive('test')
         with Repository(self.repository_path, exclusive=True) as repository:
             manifest, key = Manifest.load(repository, Manifest.NO_OPERATION_CHECK)
@@ -1655,7 +1655,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self.assert_not_in('test', output)
 
     def test_delete_double_force(self):
-        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=none')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=none')
         self.create_src_archive('test')
         with Repository(self.repository_path, exclusive=True) as repository:
             manifest, key = Manifest.load(repository, Manifest.NO_OPERATION_CHECK)
@@ -1669,7 +1669,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self.assert_not_in('test', output)
 
     def test_corrupted_repository(self):
-        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
         self.create_src_archive('test')
         self.cmd(f'--repo={self.repository_location}', 'extract', 'test', '--dry-run')
         output = self.cmd(f'--repo={self.repository_location}', 'check', '--show-version')
@@ -1684,7 +1684,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self.assert_in('Starting repository check', output)  # --info given for root logger
 
     def test_readonly_check(self):
-        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
         self.create_src_archive('test')
         with self.read_only(self.repository_path):
             # verify that command normally doesn't work with read-only repo
@@ -1699,7 +1699,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
             self.cmd(f'--repo={self.repository_location}', 'check', '--verify-data', '--bypass-lock')
 
     def test_readonly_diff(self):
-        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
         self.create_src_archive('a')
         self.create_src_archive('b')
         with self.read_only(self.repository_path):
@@ -1715,7 +1715,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
             self.cmd(f'--repo={self.repository_location}', 'diff', 'a', 'b', '--bypass-lock')
 
     def test_readonly_export_tar(self):
-        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
         self.create_src_archive('test')
         with self.read_only(self.repository_path):
             # verify that command normally doesn't work with read-only repo
@@ -1730,7 +1730,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
             self.cmd(f'--repo={self.repository_location}', 'export-tar', 'test', 'test.tar', '--bypass-lock')
 
     def test_readonly_extract(self):
-        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
         self.create_src_archive('test')
         with self.read_only(self.repository_path):
             # verify that command normally doesn't work with read-only repo
@@ -1745,7 +1745,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
             self.cmd(f'--repo={self.repository_location}', 'extract', 'test', '--bypass-lock')
 
     def test_readonly_info(self):
-        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
         self.create_src_archive('test')
         with self.read_only(self.repository_path):
             # verify that command normally doesn't work with read-only repo
@@ -1760,7 +1760,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
             self.cmd(f'--repo={self.repository_location}', 'rinfo', '--bypass-lock')
 
     def test_readonly_list(self):
-        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
         self.create_src_archive('test')
         with self.read_only(self.repository_path):
             # verify that command normally doesn't work with read-only repo
@@ -1776,7 +1776,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
 
     @unittest.skipUnless(llfuse, 'llfuse not installed')
     def test_readonly_mount(self):
-        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
         self.create_src_archive('test')
         with self.read_only(self.repository_path):
             # verify that command normally doesn't work with read-only repo
@@ -1797,13 +1797,13 @@ class ArchiverTestCase(ArchiverTestCaseBase):
     @pytest.mark.skipif('BORG_TESTS_IGNORE_MODES' in os.environ, reason='modes unreliable')
     def test_umask(self):
         self.create_regular_file('file1', size=1024 * 80)
-        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
         self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
         mode = os.stat(self.repository_path).st_mode
         self.assertEqual(stat.S_IMODE(mode), 0o700)
 
     def test_create_dry_run(self):
-        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
         self.cmd(f'--repo={self.repository_location}', 'create', '--dry-run', 'test', 'input')
         # Make sure no archive has been created
         with Repository(self.repository_path) as repository:
@@ -1826,23 +1826,23 @@ class ArchiverTestCase(ArchiverTestCaseBase):
             assert excinfo.value.args == (['unknown-feature'],)
 
     def test_unknown_feature_on_create(self):
-        print(self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey'))
+        print(self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey'))
         self.add_unknown_feature(Manifest.Operation.WRITE)
         self.cmd_raises_unknown_feature([f'--repo={self.repository_location}', 'create', 'test', 'input'])
 
     def test_unknown_feature_on_cache_sync(self):
-        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
         self.cmd(f'--repo={self.repository_location}', 'rdelete', '--cache-only')
         self.add_unknown_feature(Manifest.Operation.READ)
         self.cmd_raises_unknown_feature([f'--repo={self.repository_location}', 'create', 'test', 'input'])
 
     def test_unknown_feature_on_change_passphrase(self):
-        print(self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey'))
+        print(self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey'))
         self.add_unknown_feature(Manifest.Operation.CHECK)
         self.cmd_raises_unknown_feature([f'--repo={self.repository_location}', 'key', 'change-passphrase'])
 
     def test_unknown_feature_on_read(self):
-        print(self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey'))
+        print(self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey'))
         self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
         self.add_unknown_feature(Manifest.Operation.READ)
         with changedir('output'):
@@ -1852,13 +1852,13 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self.cmd_raises_unknown_feature([f'--repo={self.repository_location}', 'info', '-a', 'test'])
 
     def test_unknown_feature_on_rename(self):
-        print(self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey'))
+        print(self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey'))
         self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
         self.add_unknown_feature(Manifest.Operation.CHECK)
         self.cmd_raises_unknown_feature([f'--repo={self.repository_location}', 'rename', 'test', 'other'])
 
     def test_unknown_feature_on_delete(self):
-        print(self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey'))
+        print(self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey'))
         self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
         self.add_unknown_feature(Manifest.Operation.DELETE)
         # delete of an archive raises
@@ -1869,7 +1869,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
 
     @unittest.skipUnless(llfuse, 'llfuse not installed')
     def test_unknown_feature_on_mount(self):
-        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
         self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
         self.add_unknown_feature(Manifest.Operation.READ)
         mountpoint = os.path.join(self.tmpdir, 'mountpoint')
@@ -1884,7 +1884,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         else:
             path_prefix = ''
 
-        print(self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey'))
+        print(self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey'))
 
         with Repository(self.repository_path, exclusive=True) as repository:
             if path_prefix:
@@ -1920,13 +1920,13 @@ class ArchiverTestCase(ArchiverTestCaseBase):
 
     def test_progress_on(self):
         self.create_regular_file('file1', size=1024 * 80)
-        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
         output = self.cmd(f'--repo={self.repository_location}', 'create', 'test4', 'input', '--progress')
         self.assert_in("\r", output)
 
     def test_progress_off(self):
         self.create_regular_file('file1', size=1024 * 80)
-        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
         output = self.cmd(f'--repo={self.repository_location}', 'create', 'test5', 'input')
         self.assert_not_in("\r", output)
 
@@ -1937,7 +1937,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self.create_regular_file('file1', size=1024 * 80)
         time.sleep(1)  # file2 must have newer timestamps than file1
         self.create_regular_file('file2', size=1024 * 80)
-        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
         output = self.cmd(f'--repo={self.repository_location}', 'create', '--list', 'test', 'input')
         self.assert_in("A input/file1", output)
         self.assert_in("A input/file2", output)
@@ -1953,7 +1953,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self.create_regular_file('file1', contents=b'123')
         time.sleep(1)  # file2 must have newer timestamps than file1
         self.create_regular_file('file2', size=10)
-        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
         output = self.cmd(f'--repo={self.repository_location}', 'create', 'test1', 'input',
                           '--list', '--files-cache=ctime,size')
         # modify file1, but cheat with the mtime (and atime) and also keep same size:
@@ -1970,7 +1970,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self.create_regular_file('file1', size=10)
         time.sleep(1)  # file2 must have newer timestamps than file1
         self.create_regular_file('file2', size=10)
-        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
         output = self.cmd(f'--repo={self.repository_location}', 'create',
                           '--list', '--files-cache=mtime,size', 'test1', 'input')
         # change mode of file1, no content change:
@@ -1986,7 +1986,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self.create_regular_file('file1', size=10)
         time.sleep(1)  # file2 must have newer timestamps than file1
         self.create_regular_file('file2', size=10)
-        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
         output = self.cmd(f'--repo={self.repository_location}', 'create',
                           '--list', '--files-cache=rechunk,ctime', 'test1', 'input')
         # no changes here, but this mode rechunks unconditionally
@@ -2003,7 +2003,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         if has_lchflags:
             self.create_regular_file('file3', size=1024 * 80)
             platform.set_flags(os.path.join(self.input_path, 'file3'), stat.UF_NODUMP)
-        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
         output = self.cmd(f'--repo={self.repository_location}', 'create', '--list', '--exclude-nodump', 'test', 'input')
         self.assert_in("A input/file1", output)
         self.assert_in("A input/file2", output)
@@ -2019,7 +2019,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
 
     def test_create_json(self):
         self.create_regular_file('file1', size=1024 * 80)
-        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
         create_info = json.loads(self.cmd(f'--repo={self.repository_location}', 'create', '--json',
                                           'test', 'input'))
         # The usual keys
@@ -2039,7 +2039,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self.create_regular_file('file1', size=1024 * 80)
         time.sleep(1)  # file2 must have newer timestamps than file1
         self.create_regular_file('file2', size=1024 * 80)
-        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
         # no listing by default
         output = self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
         self.assert_not_in('file1', output)
@@ -2069,7 +2069,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
             finally:
                 os.close(fd)
 
-        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
         data = b'foobar' * 1000
 
         fifo_fn = os.path.join(self.input_path, 'fifo')
@@ -2092,20 +2092,20 @@ class ArchiverTestCase(ArchiverTestCaseBase):
 
     def test_create_read_special_broken_symlink(self):
         os.symlink('somewhere does not exist', os.path.join(self.input_path, 'link'))
-        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
         self.cmd(f'--repo={self.repository_location}', 'create', '--read-special', 'test', 'input')
         output = self.cmd(f'--repo={self.repository_location}', 'list', 'test')
         assert 'input/link -> somewhere does not exist' in output
 
     # def test_cmdline_compatibility(self):
     #    self.create_regular_file('file1', size=1024 * 80)
-    #    self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+    #    self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
     #    self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
     #    output = self.cmd('foo', self.repository_location, '--old')
     #    self.assert_in('"--old" has been deprecated. Use "--new" instead', output)
 
     def test_prune_repository(self):
-        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
         self.cmd(f'--repo={self.repository_location}', 'create', 'test1', src_dir)
         self.cmd(f'--repo={self.repository_location}', 'create', 'test2', src_dir)
         # these are not really a checkpoints, but they look like some:
@@ -2154,7 +2154,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
 
     # This test must match docs/misc/prune-example.txt
     def test_prune_repository_example(self):
-        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
         # Archives that will be kept, per the example
         # Oldest archive
         self._create_archive_ts('test01', 2015, 1, 1)
@@ -2215,7 +2215,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
 
     # With an initial and daily backup, prune daily until oldest is replaced by a monthly backup
     def test_prune_retain_and_expire_oldest(self):
-        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
         # Initial backup
         self._create_archive_ts('original_archive', 2020, 9, 1, 11, 15)
         # Archive and prune daily for 30 days
@@ -2238,7 +2238,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self.assert_not_in('original_archive', output)
 
     def test_prune_repository_save_space(self):
-        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
         self.cmd(f'--repo={self.repository_location}', 'create', 'test1', src_dir)
         self.cmd(f'--repo={self.repository_location}', 'create', 'test2', src_dir)
         output = self.cmd(f'--repo={self.repository_location}', 'prune', '--list', '--dry-run', '--keep-daily=1')
@@ -2253,7 +2253,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self.assert_in('test2', output)
 
     def test_prune_repository_prefix(self):
-        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
         self.cmd(f'--repo={self.repository_location}', 'create', 'foo-2015-08-12-10:00', src_dir)
         self.cmd(f'--repo={self.repository_location}', 'create', 'foo-2015-08-12-20:00', src_dir)
         self.cmd(f'--repo={self.repository_location}', 'create', 'bar-2015-08-12-10:00', src_dir)
@@ -2274,7 +2274,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self.assert_in('bar-2015-08-12-20:00', output)
 
     def test_prune_repository_glob(self):
-        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
         self.cmd(f'--repo={self.repository_location}', 'create', '2015-08-12-10:00-foo', src_dir)
         self.cmd(f'--repo={self.repository_location}', 'create', '2015-08-12-20:00-foo', src_dir)
         self.cmd(f'--repo={self.repository_location}', 'create', '2015-08-12-10:00-bar', src_dir)
@@ -2295,7 +2295,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self.assert_in('2015-08-12-20:00-bar', output)
 
     def test_list_prefix(self):
-        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
         self.cmd(f'--repo={self.repository_location}', 'create', 'test-1', src_dir)
         self.cmd(f'--repo={self.repository_location}', 'create', 'something-else-than-test-1', src_dir)
         self.cmd(f'--repo={self.repository_location}', 'create', 'test-2', src_dir)
@@ -2305,7 +2305,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self.assert_not_in('something-else', output)
 
     def test_list_format(self):
-        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
         self.cmd(f'--repo={self.repository_location}', 'create', 'test', src_dir)
         output_1 = self.cmd(f'--repo={self.repository_location}', 'list', 'test')
         output_2 = self.cmd(f'--repo={self.repository_location}', 'list', 'test', '--format', '{mode} {user:6} {group:6} {size:8d} {mtime} {path}{extra}{NEWLINE}')
@@ -2314,7 +2314,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self.assertNotEqual(output_1, output_3)
 
     def test_archives_format(self):
-        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
         self.cmd(f'--repo={self.repository_location}', 'create', '--comment', 'comment 1', 'test-1', src_dir)
         self.cmd(f'--repo={self.repository_location}', 'create', '--comment', 'comment 2', 'test-2', src_dir)
         output_1 = self.cmd(f'--repo={self.repository_location}', 'rlist')
@@ -2331,14 +2331,14 @@ class ArchiverTestCase(ArchiverTestCaseBase):
     def test_list_hash(self):
         self.create_regular_file('empty_file', size=0)
         self.create_regular_file('amb', contents=b'a' * 1000000)
-        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
         self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
         output = self.cmd(f'--repo={self.repository_location}', 'list', 'test', '--format', '{sha256} {path}{NL}')
         assert "cdc76e5c9914fb9281a1c7e284d73e67f1809a48a497200e046d39ccc7112cd0 input/amb" in output
         assert "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855 input/empty_file" in output
 
     def test_list_consider_checkpoints(self):
-        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
         self.cmd(f'--repo={self.repository_location}', 'create', 'test1', src_dir)
         # these are not really a checkpoints, but they look like some:
         self.cmd(f'--repo={self.repository_location}', 'create', 'test2.checkpoint', src_dir)
@@ -2358,7 +2358,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         with open(os.path.join(self.input_path, 'two_chunks'), 'wb') as fd:
             fd.write(b'abba' * 2000000)
             fd.write(b'baab' * 2000000)
-        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
         self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
         output = self.cmd(f'--repo={self.repository_location}', 'list', 'test', '--format', '{num_chunks} {unique_chunks} {path}{NL}')
         assert "0 0 input/empty_file" in output
@@ -2366,7 +2366,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
 
     def test_list_size(self):
         self.create_regular_file('compressible_file', size=10000)
-        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
         self.cmd(f'--repo={self.repository_location}', 'create', '-C', 'lz4', 'test', 'input')
         output = self.cmd(f'--repo={self.repository_location}', 'list', 'test', '--format', '{size} {path}{NL}')
         size, path = output.split("\n")[1].split(" ")
@@ -2374,7 +2374,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
 
     def test_list_json(self):
         self.create_regular_file('file1', size=1024 * 80)
-        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
         self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
         list_repo = json.loads(self.cmd(f'--repo={self.repository_location}', 'rlist', '--json'))
         repository = list_repo['repository']
@@ -2402,7 +2402,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
 
     def test_log_json(self):
         self.create_test_files()
-        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
         log = self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input', '--log-json', '--list', '--debug')
         messages = {}  # type -> message, one of each kind
         for line in log.splitlines():
@@ -2420,7 +2420,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
 
     def test_debug_profile(self):
         self.create_test_files()
-        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
         self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input', '--debug-profile=create.prof')
         self.cmd('debug', 'convert-profile', 'create.prof', 'create.pyprof')
         stats = pstats.Stats('create.pyprof')
@@ -2434,12 +2434,12 @@ class ArchiverTestCase(ArchiverTestCaseBase):
 
     def test_common_options(self):
         self.create_test_files()
-        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
         log = self.cmd(f'--repo={self.repository_location}', '--debug', 'create', 'test', 'input')
         assert 'security: read previous location' in log
 
     def test_change_passphrase(self):
-        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
         os.environ['BORG_NEW_PASSPHRASE'] = 'newpassphrase'
         # here we have both BORG_PASSPHRASE and BORG_NEW_PASSPHRASE set:
         self.cmd(f'--repo={self.repository_location}', 'key', 'change-passphrase')
@@ -2447,7 +2447,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self.cmd(f'--repo={self.repository_location}', 'rlist')
 
     def test_change_location_to_keyfile(self):
-        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
         log = self.cmd(f'--repo={self.repository_location}', 'rinfo')
         assert '(repokey)' in log
         self.cmd(f'--repo={self.repository_location}', 'key', 'change-location', 'keyfile')
@@ -2455,7 +2455,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         assert '(key file)' in log
 
     def test_change_location_to_b2keyfile(self):
-        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey-blake2')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey-blake2')
         log = self.cmd(f'--repo={self.repository_location}', 'rinfo')
         assert '(repokey BLAKE2b)' in log
         self.cmd(f'--repo={self.repository_location}', 'key', 'change-location', 'keyfile')
@@ -2463,7 +2463,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         assert '(key file BLAKE2b)' in log
 
     def test_change_location_to_repokey(self):
-        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=keyfile')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=keyfile')
         log = self.cmd(f'--repo={self.repository_location}', 'rinfo')
         assert '(key file)' in log
         self.cmd(f'--repo={self.repository_location}', 'key', 'change-location', 'repokey')
@@ -2471,7 +2471,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         assert '(repokey)' in log
 
     def test_change_location_to_b2repokey(self):
-        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=keyfile-blake2')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=keyfile-blake2')
         log = self.cmd(f'--repo={self.repository_location}', 'rinfo')
         assert '(key file BLAKE2b)' in log
         self.cmd(f'--repo={self.repository_location}', 'key', 'change-location', 'repokey')
@@ -2479,7 +2479,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         assert '(repokey BLAKE2b)' in log
 
     def test_break_lock(self):
-        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
         self.cmd(f'--repo={self.repository_location}', 'break-lock')
 
     def test_usage(self):
@@ -2489,9 +2489,9 @@ class ArchiverTestCase(ArchiverTestCaseBase):
     def test_help(self):
         assert 'Borg' in self.cmd('help')
         assert 'patterns' in self.cmd('help', 'patterns')
-        assert 'Initialize' in self.cmd('help', 'init')
-        assert 'positional arguments' not in self.cmd('help', 'init', '--epilog-only')
-        assert 'This command initializes' not in self.cmd('help', 'init', '--usage-only')
+        assert 'creates a new, empty repository' in self.cmd('help', 'rcreate')
+        assert 'positional arguments' not in self.cmd('help', 'rcreate', '--epilog-only')
+        assert 'creates a new, empty repository' not in self.cmd('help', 'rcreate', '--usage-only')
 
     @unittest.skipUnless(llfuse, 'llfuse not installed')
     def test_fuse(self):
@@ -2506,7 +2506,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
                 noatime_used = flags_noatime != flags_normal
                 return noatime_used and atime_before == atime_after
 
-        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
         self.create_test_files()
         have_noatime = has_noatime('input/file1')
         self.cmd(f'--repo={self.repository_location}', 'create', '--exclude-nodump', '--atime', 'archive', 'input')
@@ -2595,7 +2595,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
 
     @unittest.skipUnless(llfuse, 'llfuse not installed')
     def test_fuse_versions_view(self):
-        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
         self.create_regular_file('test', contents=b'first')
         if are_hardlinks_supported():
             self.create_regular_file('hardlink1', contents=b'123456')
@@ -2627,7 +2627,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
 
     @unittest.skipUnless(llfuse, 'llfuse not installed')
     def test_fuse_allow_damaged_files(self):
-        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
         self.create_src_archive('archive')
         # Get rid of a chunk and repair it
         archive, repository = self.open_archive('archive')
@@ -2652,7 +2652,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
 
     @unittest.skipUnless(llfuse, 'llfuse not installed')
     def test_fuse_mount_options(self):
-        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
         self.create_src_archive('arch11')
         self.create_src_archive('arch12')
         self.create_src_archive('arch21')
@@ -2726,7 +2726,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         # Decorate
         borg.locking.Lock.migrate_lock = write_assert_data(borg.locking.Lock.migrate_lock)
         try:
-            self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=none')
+            self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=none')
             self.create_src_archive('arch')
             mountpoint = os.path.join(self.tmpdir, 'mountpoint')
             # In order that the decoration is kept for the borg mount process, we must not spawn, but actually fork;
@@ -2779,7 +2779,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
 
         self.create_test_files()
         os.environ['BORG_PASSPHRASE'] = 'passphrase'
-        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=' + method)
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=' + method)
         verify_uniqueness()
         self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
         verify_uniqueness()
@@ -2796,7 +2796,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
 
     def test_debug_dump_archive_items(self):
         self.create_test_files()
-        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
         self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
         with changedir('output'):
             output = self.cmd(f'--repo={self.repository_location}', 'debug', 'dump-archive-items', 'test')
@@ -2806,7 +2806,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
 
     def test_debug_dump_repo_objs(self):
         self.create_test_files()
-        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
         self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
         with changedir('output'):
             output = self.cmd(f'--repo={self.repository_location}', 'debug', 'dump-repo-objs')
@@ -2815,7 +2815,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         assert 'Done.' in output
 
     def test_debug_put_get_delete_obj(self):
-        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
         data = b'some data'
         hexkey = sha256(data).hexdigest()
         self.create_regular_file('file', contents=data)
@@ -2838,19 +2838,19 @@ class ArchiverTestCase(ArchiverTestCaseBase):
             raise EOFError
 
         with patch.object(FlexiKey, 'create', raise_eof):
-            self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey', exit_code=1)
+            self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey', exit_code=1)
         assert not os.path.exists(self.repository_location)
 
     def test_init_requires_encryption_option(self):
-        self.cmd(f'--repo={self.repository_location}', 'init', exit_code=2)
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', exit_code=2)
 
     def test_init_nested_repositories(self):
-        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
         if self.FORK_DEFAULT:
-            self.cmd(f'--repo={self.repository_location}/nested', 'init', '--encryption=repokey', exit_code=2)
+            self.cmd(f'--repo={self.repository_location}/nested', 'rcreate', '--encryption=repokey', exit_code=2)
         else:
             with pytest.raises(Repository.AlreadyExists):
-                self.cmd(f'--repo={self.repository_location}/nested', 'init', '--encryption=repokey')
+                self.cmd(f'--repo={self.repository_location}/nested', 'rcreate', '--encryption=repokey')
 
     def test_init_refuse_to_overwrite_keyfile(self):
         """BORG_KEY_FILE=something borg init should quit if "something" already exists.
@@ -2858,10 +2858,10 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         See https://github.com/borgbackup/borg/pull/6046"""
         keyfile = os.path.join(self.tmpdir, 'keyfile')
         with environment_variable(BORG_KEY_FILE=keyfile):
-            self.cmd(f'--repo={self.repository_location}0', 'init', '--encryption=keyfile')
+            self.cmd(f'--repo={self.repository_location}0', 'rcreate', '--encryption=keyfile')
             with open(keyfile) as file:
                 before = file.read()
-            arg = (f'--repo={self.repository_location}1', 'init', '--encryption=keyfile')
+            arg = (f'--repo={self.repository_location}1', 'rcreate', '--encryption=keyfile')
             if self.FORK_DEFAULT:
                 self.cmd(*arg, exit_code=2)
             else:
@@ -2893,7 +2893,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
             assert id in seen
 
     def test_check_cache(self):
-        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
         self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
         with self.open_repository() as repository:
             manifest, key = Manifest.load(repository, Manifest.NO_OPERATION_CHECK)
@@ -2905,13 +2905,13 @@ class ArchiverTestCase(ArchiverTestCaseBase):
             self.check_cache()
 
     def test_recreate_target_rc(self):
-        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
         output = self.cmd(f'--repo={self.repository_location}', 'recreate', '--target=asdf', exit_code=2)
         assert 'Need to specify single archive' in output
 
     def test_recreate_target(self):
         self.create_test_files()
-        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
         self.check_cache()
         self.cmd(f'--repo={self.repository_location}', 'create', 'test0', 'input')
         self.check_cache()
@@ -2931,7 +2931,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
     def test_recreate_basic(self):
         self.create_test_files()
         self.create_regular_file('dir2/file3', size=1024 * 80)
-        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
         self.cmd(f'--repo={self.repository_location}', 'create', 'test0', 'input')
         self.cmd(f'--repo={self.repository_location}', 'recreate', 'test0', 'input/dir2', '-e', 'input/dir2/file3')
         self.check_cache()
@@ -2961,7 +2961,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         with open(os.path.join(self.input_path, 'large_file'), 'wb') as fd:
             fd.write(b'a' * 280)
             fd.write(b'b' * 280)
-        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
         self.cmd(f'--repo={self.repository_location}', 'create', 'test1', 'input', '--chunker-params', '7,9,8,128')
         self.cmd(f'--repo={self.repository_location}', 'create', 'test2', 'input', '--files-cache=disabled')
         list = self.cmd(f'--repo={self.repository_location}', 'list', 'test1', 'input/large_file',
@@ -2978,7 +2978,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
 
     def test_recreate_recompress(self):
         self.create_regular_file('compressible', size=10000)
-        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
         self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input', '-C', 'none')
         file_list = self.cmd(f'--repo={self.repository_location}', 'list', 'test', 'input/compressible',
                              '--format', '{size} {sha256}')
@@ -2993,7 +2993,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
     def test_recreate_timestamp(self):
         local_timezone = datetime.now(timezone(timedelta(0))).astimezone().tzinfo
         self.create_test_files()
-        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
         self.cmd(f'--repo={self.repository_location}', 'create', 'test0', 'input')
         self.cmd(f'--repo={self.repository_location}', 'recreate', 'test0', '--timestamp', "1970-01-02T00:00:00",
                  '--comment', 'test')
@@ -3005,7 +3005,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
 
     def test_recreate_dry_run(self):
         self.create_regular_file('compressible', size=10000)
-        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
         self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
         archives_before = self.cmd(f'--repo={self.repository_location}', 'list', 'test')
         self.cmd(f'--repo={self.repository_location}', 'recreate', '-n', '-e', 'input/compressible')
@@ -3015,7 +3015,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
 
     def test_recreate_skips_nothing_to_do(self):
         self.create_regular_file('file1', size=1024 * 80)
-        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
         self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
         info_before = self.cmd(f'--repo={self.repository_location}', 'info', '-a', 'test')
         self.cmd(f'--repo={self.repository_location}', 'recreate', '--chunker-params', 'default')
@@ -3024,13 +3024,13 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         assert info_before == info_after  # includes archive ID
 
     def test_with_lock(self):
-        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
         lock_path = os.path.join(self.repository_path, 'lock.exclusive')
         cmd = 'python3', '-c', 'import os, sys; sys.exit(42 if os.path.exists("%s") else 23)' % lock_path
         self.cmd(f'--repo={self.repository_location}', 'with-lock', *cmd, fork=True, exit_code=42)
 
     def test_recreate_list_output(self):
-        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
         self.create_regular_file('file1', size=0)
         self.create_regular_file('file2', size=0)
         self.create_regular_file('file3', size=0)
@@ -3060,13 +3060,13 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self.assert_not_in("x input/file5", output)
 
     def test_bad_filters(self):
-        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
         self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
         self.cmd(f'--repo={self.repository_location}', 'delete', '--first', '1', '--last', '1', fork=True, exit_code=2)
 
     def test_key_export_keyfile(self):
         export_file = self.output_path + '/exported'
-        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption', 'keyfile')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption', 'keyfile')
         repo_id = self._extract_repository_id(self.repository_path)
         self.cmd(f'--repo={self.repository_location}', 'key', 'export', export_file)
 
@@ -3092,7 +3092,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         assert key_contents2 == key_contents
 
     def test_key_import_keyfile_with_borg_key_file(self):
-        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption', 'keyfile')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption', 'keyfile')
 
         exported_key_file = os.path.join(self.output_path, 'exported')
         self.cmd(f'--repo={self.repository_location}', 'key', 'export', exported_key_file)
@@ -3113,7 +3113,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
 
     def test_key_export_repokey(self):
         export_file = self.output_path + '/exported'
-        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption', 'repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption', 'repokey')
         repo_id = self._extract_repository_id(self.repository_path)
         self.cmd(f'--repo={self.repository_location}', 'key', 'export', export_file)
 
@@ -3144,7 +3144,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
 
     def test_key_export_qr(self):
         export_file = self.output_path + '/exported.html'
-        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption', 'repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption', 'repokey')
         repo_id = self._extract_repository_id(self.repository_path)
         self.cmd(f'--repo={self.repository_location}', 'key', 'export', '--qr-html', export_file)
 
@@ -3159,13 +3159,13 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         export_directory = self.output_path + '/exported'
         os.mkdir(export_directory)
 
-        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption', 'repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption', 'repokey')
 
         self.cmd(f'--repo={self.repository_location}', 'key', 'export', export_directory, exit_code=EXIT_ERROR)
 
     def test_key_import_errors(self):
         export_file = self.output_path + '/exported'
-        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption', 'keyfile')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption', 'keyfile')
 
         self.cmd(f'--repo={self.repository_location}', 'key', 'import', export_file, exit_code=EXIT_ERROR)
 
@@ -3191,7 +3191,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         repo_id = 'e294423506da4e1ea76e8dcdf1a3919624ae3ae496fddf905610c351d3f09239'
 
         export_file = self.output_path + '/exported'
-        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption', 'keyfile')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption', 'keyfile')
         self._set_repository_id(self.repository_path, unhexlify(repo_id))
 
         key_file = self.keys_path + '/' + os.listdir(self.keys_path)[0]
@@ -3215,7 +3215,7 @@ id: 2 / e29442 3506da 4e1ea7 / 25f62a 5a3d41 - 02
 
     def test_key_import_paperkey(self):
         repo_id = 'e294423506da4e1ea76e8dcdf1a3919624ae3ae496fddf905610c351d3f09239'
-        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption', 'keyfile')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption', 'keyfile')
         self._set_repository_id(self.repository_path, unhexlify(repo_id))
 
         key_file = self.keys_path + '/' + os.listdir(self.keys_path)[0]
@@ -3260,7 +3260,7 @@ id: 2 / e29442 3506da 4e1ea7 / 25f62a 5a3d41 - 02
 
     def test_debug_dump_manifest(self):
         self.create_regular_file('file1', size=1024 * 80)
-        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
         self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
         dump_file = self.output_path + '/dump'
         output = self.cmd(f'--repo={self.repository_location}', 'debug', 'dump-manifest', dump_file)
@@ -3275,7 +3275,7 @@ id: 2 / e29442 3506da 4e1ea7 / 25f62a 5a3d41 - 02
 
     def test_debug_dump_archive(self):
         self.create_regular_file('file1', size=1024 * 80)
-        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
         self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
         dump_file = self.output_path + '/dump'
         output = self.cmd(f'--repo={self.repository_location}', 'debug', 'dump-archive', 'test', dump_file)
@@ -3288,7 +3288,7 @@ id: 2 / e29442 3506da 4e1ea7 / 25f62a 5a3d41 - 02
         assert '_items' in result
 
     def test_debug_refcount_obj(self):
-        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
         output = self.cmd(f'--repo={self.repository_location}', 'debug', 'refcount-obj', '0' * 64).strip()
         assert output == 'object 0000000000000000000000000000000000000000000000000000000000000000 not found [info from chunks cache].'
 
@@ -3307,14 +3307,14 @@ id: 2 / e29442 3506da 4e1ea7 / 25f62a 5a3d41 - 02
         assert 'Python' in output
 
     def test_benchmark_crud(self):
-        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
         with environment_variable(_BORG_BENCHMARK_CRUD_TEST='YES'):
             self.cmd(f'--repo={self.repository_location}', 'benchmark', 'crud', self.input_path)
 
     def test_config(self):
         self.create_test_files()
         os.unlink('input/flagfile')
-        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
         output = self.cmd(f'--repo={self.repository_location}', 'config', '--list')
         self.assert_in('[repository]', output)
         self.assert_in('version', output)
@@ -3357,7 +3357,7 @@ id: 2 / e29442 3506da 4e1ea7 / 25f62a 5a3d41 - 02
     def test_export_tar(self):
         self.create_test_files()
         os.unlink('input/flagfile')
-        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
         self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
         self.cmd(f'--repo={self.repository_location}', 'export-tar', 'test', 'simple.tar', '--progress', '--tar-format=GNU')
         with changedir('output'):
@@ -3372,7 +3372,7 @@ id: 2 / e29442 3506da 4e1ea7 / 25f62a 5a3d41 - 02
             pytest.skip('gzip is not installed')
         self.create_test_files()
         os.unlink('input/flagfile')
-        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
         self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
         list = self.cmd(f'--repo={self.repository_location}', 'export-tar', 'test', 'simple.tar.gz',
                         '--list', '--tar-format=GNU')
@@ -3388,7 +3388,7 @@ id: 2 / e29442 3506da 4e1ea7 / 25f62a 5a3d41 - 02
             pytest.skip('gzip is not installed')
         self.create_test_files()
         os.unlink('input/flagfile')
-        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
         self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
         list = self.cmd(f'--repo={self.repository_location}', 'export-tar', 'test', 'simple.tar',
                         '--strip-components=1', '--list', '--tar-format=GNU')
@@ -3427,7 +3427,7 @@ id: 2 / e29442 3506da 4e1ea7 / 25f62a 5a3d41 - 02
     def test_import_tar(self, tar_format='PAX'):
         self.create_test_files(create_hardlinks=False)  # hardlinks become separate files
         os.unlink('input/flagfile')
-        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=none')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=none')
         self.cmd(f'--repo={self.repository_location}', 'create', 'src', 'input')
         self.cmd(f'--repo={self.repository_location}', 'export-tar', 'src', 'simple.tar', f'--tar-format={tar_format}')
         self.cmd(f'--repo={self.repository_location}', 'import-tar', 'dst', 'simple.tar')
@@ -3441,7 +3441,7 @@ id: 2 / e29442 3506da 4e1ea7 / 25f62a 5a3d41 - 02
             pytest.skip('gzip is not installed')
         self.create_test_files(create_hardlinks=False)  # hardlinks become separate files
         os.unlink('input/flagfile')
-        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=none')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=none')
         self.cmd(f'--repo={self.repository_location}', 'create', 'src', 'input')
         self.cmd(f'--repo={self.repository_location}', 'export-tar', 'src', 'simple.tgz', f'--tar-format={tar_format}')
         self.cmd(f'--repo={self.repository_location}', 'import-tar', 'dst', 'simple.tgz')
@@ -3451,7 +3451,7 @@ id: 2 / e29442 3506da 4e1ea7 / 25f62a 5a3d41 - 02
 
     def test_roundtrip_pax_borg(self):
         self.create_test_files()
-        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=none')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=none')
         self.cmd(f'--repo={self.repository_location}', 'create', 'src', 'input')
         self.cmd(f'--repo={self.repository_location}', 'export-tar', 'src', 'simple.tar', '--tar-format=BORG')
         self.cmd(f'--repo={self.repository_location}', 'import-tar', 'dst', 'simple.tar')
@@ -3469,7 +3469,7 @@ id: 2 / e29442 3506da 4e1ea7 / 25f62a 5a3d41 - 02
 
         self.create_regular_file('file')
         xattr.setxattr(b'input/file', b'user.attribute%p', b'value')
-        self.cmd('init', self.repository_location, '-e' 'none')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', '-e' 'none')
         self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
         with changedir('output'):
             with patch.object(xattr, 'setxattr', patched_setxattr_EACCES):
@@ -3485,7 +3485,7 @@ id: 2 / e29442 3506da 4e1ea7 / 25f62a 5a3d41 - 02
 
         os.makedirs(os.path.join(self.input_path, 'dir%p'))
         xattr.setxattr(b'input/dir%p', b'user.attribute', b'value')
-        self.cmd(f'--repo={self.repository_location}', 'init', '-e' 'none')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', '-e' 'none')
         self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
         with changedir('output'):
             with patch.object(xattr, 'setxattr', patched_setxattr_EACCES):
@@ -3504,7 +3504,7 @@ id: 2 / e29442 3506da 4e1ea7 / 25f62a 5a3d41 - 02
         It should be possible to retrieve the data from an archive even if
         both the client and the server forget the nonce"""
         self.create_regular_file('file1', contents=b'Hello, borg')
-        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
         self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
         # Oops! We have removed the repo-side memory of the nonce!
         # See https://github.com/borgbackup/borg/issues/5858
@@ -3535,7 +3535,7 @@ id: 2 / e29442 3506da 4e1ea7 / 25f62a 5a3d41 - 02
         repo. Otherwise we can just use our own copy of the nonce.
         """
         self.create_regular_file('file1', contents=b'Hello, borg')
-        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
         self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
         # Oops! We have removed the repo-side memory of the nonce!
         # See https://github.com/borgbackup/borg/issues/5858
@@ -3547,20 +3547,20 @@ id: 2 / e29442 3506da 4e1ea7 / 25f62a 5a3d41 - 02
 
     def test_init_defaults_to_argon2(self):
         """https://github.com/borgbackup/borg/issues/747#issuecomment-1076160401"""
-        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
         with Repository(self.repository_path) as repository:
             key = msgpack.unpackb(a2b_base64(repository.load_key()))
         assert key['algorithm'] == 'argon2 chacha20-poly1305'
 
     def test_init_with_explicit_key_algorithm(self):
         """https://github.com/borgbackup/borg/issues/747#issuecomment-1076160401"""
-        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey', '--key-algorithm=pbkdf2')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey', '--key-algorithm=pbkdf2')
         with Repository(self.repository_path) as repository:
             key = msgpack.unpackb(a2b_base64(repository.load_key()))
         assert key['algorithm'] == 'sha256'
 
     def verify_change_passphrase_does_not_change_algorithm(self, given_algorithm, expected_algorithm):
-        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey', '--key-algorithm', given_algorithm)
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey', '--key-algorithm', given_algorithm)
         os.environ['BORG_NEW_PASSPHRASE'] = 'newpassphrase'
 
         self.cmd(f'--repo={self.repository_location}', 'key', 'change-passphrase')
@@ -3576,7 +3576,7 @@ id: 2 / e29442 3506da 4e1ea7 / 25f62a 5a3d41 - 02
         self.verify_change_passphrase_does_not_change_algorithm('pbkdf2', 'sha256')
 
     def verify_change_location_does_not_change_algorithm(self, given_algorithm, expected_algorithm):
-        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=keyfile', '--key-algorithm', given_algorithm)
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=keyfile', '--key-algorithm', given_algorithm)
 
         self.cmd(f'--repo={self.repository_location}', 'key', 'change-location', 'repokey')
 
@@ -3591,7 +3591,7 @@ id: 2 / e29442 3506da 4e1ea7 / 25f62a 5a3d41 - 02
         self.verify_change_location_does_not_change_algorithm('pbkdf2', 'sha256')
 
     def test_key_change_algorithm(self):
-        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey', '--key-algorithm=pbkdf2')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey', '--key-algorithm=pbkdf2')
 
         self.cmd(f'--repo={self.repository_location}', 'key', 'change-algorithm', 'argon2')
 
@@ -3650,7 +3650,7 @@ class ArchiverCheckTestCase(ArchiverTestCaseBase):
     def setUp(self):
         super().setUp()
         with patch.object(ChunkBuffer, 'BUFFER_SIZE', 10):
-            self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+            self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
             self.create_src_archive('archive1')
             self.create_src_archive('archive2')
 
@@ -3825,7 +3825,7 @@ class ArchiverCheckTestCase(ArchiverTestCaseBase):
 
     def _test_verify_data(self, *init_args):
         shutil.rmtree(self.repository_path)
-        self.cmd(f'--repo={self.repository_location}', 'init', *init_args)
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', *init_args)
         self.create_src_archive('archive1')
         archive, repository = self.open_archive('archive1')
         with repository:
@@ -3871,7 +3871,7 @@ class ManifestAuthenticationTest(ArchiverTestCaseBase):
             repository.commit(compact=False)
 
     def test_fresh_init_tam_required(self):
-        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
         repository = Repository(self.repository_path, exclusive=True)
         with repository:
             manifest, key = Manifest.load(repository, Manifest.NO_OPERATION_CHECK)
@@ -3886,7 +3886,7 @@ class ManifestAuthenticationTest(ArchiverTestCaseBase):
             self.cmd(f'--repo={self.repository_location}', 'rlist')
 
     def test_not_required(self):
-        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
         self.create_src_archive('archive1234')
         repository = Repository(self.repository_path, exclusive=True)
         with repository:
@@ -3918,7 +3918,7 @@ class ManifestAuthenticationTest(ArchiverTestCaseBase):
         self.cmd(f'--repo={self.repository_location}', 'rlist')
 
     def test_disable(self):
-        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
         self.create_src_archive('archive1234')
         self.cmd(f'--repo={self.repository_location}', 'upgrade', '--disable-tam')
         repository = Repository(self.repository_path, exclusive=True)
@@ -3926,7 +3926,7 @@ class ManifestAuthenticationTest(ArchiverTestCaseBase):
         assert not self.cmd(f'--repo={self.repository_location}', 'rlist')
 
     def test_disable2(self):
-        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
         self.create_src_archive('archive1234')
         repository = Repository(self.repository_path, exclusive=True)
         self.spoof_manifest(repository)
@@ -3943,32 +3943,32 @@ class RemoteArchiverTestCase(ArchiverTestCase):
     def test_remote_repo_restrict_to_path(self):
         # restricted to repo directory itself:
         with patch.object(RemoteRepository, 'extra_test_args', ['--restrict-to-path', self.repository_path]):
-            self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+            self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
         # restricted to repo directory itself, fail for other directories with same prefix:
         with patch.object(RemoteRepository, 'extra_test_args', ['--restrict-to-path', self.repository_path]):
             with pytest.raises(PathNotAllowed):
-                self.cmd(f'--repo={self.repository_location}_0', 'init', '--encryption=repokey')
+                self.cmd(f'--repo={self.repository_location}_0', 'rcreate', '--encryption=repokey')
 
         # restricted to a completely different path:
         with patch.object(RemoteRepository, 'extra_test_args', ['--restrict-to-path', '/foo']):
             with pytest.raises(PathNotAllowed):
-                self.cmd(f'--repo={self.repository_location}_1', 'init', '--encryption=repokey')
+                self.cmd(f'--repo={self.repository_location}_1', 'rcreate', '--encryption=repokey')
         path_prefix = os.path.dirname(self.repository_path)
         # restrict to repo directory's parent directory:
         with patch.object(RemoteRepository, 'extra_test_args', ['--restrict-to-path', path_prefix]):
-            self.cmd(f'--repo={self.repository_location}_2', 'init', '--encryption=repokey')
+            self.cmd(f'--repo={self.repository_location}_2', 'rcreate', '--encryption=repokey')
         # restrict to repo directory's parent directory and another directory:
         with patch.object(RemoteRepository, 'extra_test_args', ['--restrict-to-path', '/foo', '--restrict-to-path', path_prefix]):
-            self.cmd(f'--repo={self.repository_location}_3', 'init', '--encryption=repokey')
+            self.cmd(f'--repo={self.repository_location}_3', 'rcreate', '--encryption=repokey')
 
     def test_remote_repo_restrict_to_repository(self):
         # restricted to repo directory itself:
         with patch.object(RemoteRepository, 'extra_test_args', ['--restrict-to-repository', self.repository_path]):
-            self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+            self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
         parent_path = os.path.join(self.repository_path, '..')
         with patch.object(RemoteRepository, 'extra_test_args', ['--restrict-to-repository', parent_path]):
             with pytest.raises(PathNotAllowed):
-                self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+                self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
 
     @unittest.skip('only works locally')
     def test_debug_put_get_delete_obj(self):
@@ -3983,7 +3983,7 @@ class RemoteArchiverTestCase(ArchiverTestCase):
         pass
 
     def test_remote_repo_strip_components_doesnt_leak(self):
-        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
         self.create_regular_file('dir/file', contents=b"test file contents 1")
         self.create_regular_file('dir/file2', contents=b"test file contents 2")
         self.create_regular_file('skipped-file1', contents=b"test file contents 3")
@@ -4009,7 +4009,7 @@ class ArchiverCorruptionTestCase(ArchiverTestCaseBase):
     def setUp(self):
         super().setUp()
         self.create_test_files()
-        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
         self.cache_path = json.loads(self.cmd(f'--repo={self.repository_location}', 'rinfo', '--json'))['cache']['path']
 
     def corrupt(self, file, amount=1):
@@ -4103,7 +4103,7 @@ class DiffArchiverTestCase(ArchiverTestCaseBase):
             os.link('input/file_removed', 'input/hardlink_removed')
             os.link('input/file_removed2', 'input/hardlink_target_removed')
 
-        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
 
         # Create the first snapshot
         self.cmd(f'--repo={self.repository_location}', 'create', 'test0', 'input')
@@ -4289,7 +4289,7 @@ class DiffArchiverTestCase(ArchiverTestCaseBase):
         do_json_asserts(self.cmd(f'--repo={self.repository_location}', 'diff', 'test0', 'test1a', '--json-lines'), True)
 
     def test_sort_option(self):
-        self.cmd(f'--repo={self.repository_location}', 'init', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
 
         self.create_regular_file('a_file_removed', size=8)
         self.create_regular_file('f_file_removed', size=16)
@@ -4350,7 +4350,7 @@ def test_get_args():
     assert args.restrict_to_repositories == ['/r1', '/r2']
     # trying to cheat - try to execute different subcommand
     args = archiver.get_args(['borg', 'serve', '--restrict-to-path=/p1', '--restrict-to-path=/p2', ],
-                             'borg --repo=/ init --encryption=repokey')
+                             'borg --repo=/ rcreate --encryption=repokey')
     assert args.func == archiver.do_serve
 
     # Check that environment variables in the forced command don't cause issues. If the command
diff --git a/src/borg/testsuite/benchmark.py b/src/borg/testsuite/benchmark.py
index 0a9a4373a..7b8d93168 100644
--- a/src/borg/testsuite/benchmark.py
+++ b/src/borg/testsuite/benchmark.py
@@ -28,7 +28,7 @@ def repo_url(request, tmpdir, monkeypatch):
 
 @pytest.fixture(params=["none", "repokey"])
 def repo(request, cmd, repo_url):
-    cmd(f'--repo={repo_url}', 'init', '--encryption', request.param)
+    cmd(f'--repo={repo_url}', 'rcreate', '--encryption', request.param)
     return repo_url
 
 

From f578c20b22841838901603d144be45801fadd159 Mon Sep 17 00:00:00 2001
From: Thomas Waldmann <tw@waldmann-edv.de>
Date: Thu, 23 Jun 2022 09:50:48 +0200
Subject: [PATCH 067/160] fix benchmark tests

---
 src/borg/testsuite/benchmark.py | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/borg/testsuite/benchmark.py b/src/borg/testsuite/benchmark.py
index 7b8d93168..b23a7d800 100644
--- a/src/borg/testsuite/benchmark.py
+++ b/src/borg/testsuite/benchmark.py
@@ -57,7 +57,7 @@ def testdata(request, tmpdir_factory):
 @pytest.fixture(params=['none', 'lz4'])
 def repo_archive(request, cmd, repo, testdata):
     archive = 'test'
-    cmd(f'--repo={repo}', 'create', f'{archive}', '--compression', request.param, testdata)
+    cmd(f'--repo={repo}', 'create', '--compression', request.param, archive, testdata)
     return repo, archive
 
 
@@ -82,19 +82,19 @@ def test_extract(benchmark, cmd, repo_archive, tmpdir):
 
 def test_delete(benchmark, cmd, repo_archive):
     repo, archive = repo_archive
-    result, out = benchmark.pedantic(cmd, (f'--repo={repo}', 'delete', '--name', archive))
+    result, out = benchmark.pedantic(cmd, (f'--repo={repo}', 'delete', '-a', archive))
     assert result == 0
 
 
 def test_list(benchmark, cmd, repo_archive):
     repo, archive = repo_archive
-    result, out = benchmark(cmd, f'--repo={repo}', 'list', '--name', archive)
+    result, out = benchmark(cmd, f'--repo={repo}', 'list', archive)
     assert result == 0
 
 
 def test_info(benchmark, cmd, repo_archive):
     repo, archive = repo_archive
-    result, out = benchmark(cmd, f'--repo={repo}', 'info', '--name', archive)
+    result, out = benchmark(cmd, f'--repo={repo}', 'info', '-a', archive)
     assert result == 0
 
 

From 16b91a41ad996aa9c04be36484e178d8f2ab5eb5 Mon Sep 17 00:00:00 2001
From: Thomas Waldmann <tw@waldmann-edv.de>
Date: Thu, 23 Jun 2022 12:08:30 +0200
Subject: [PATCH 068/160] fix accidental nesting of subparsers

python 3.11-dev threw a warning that this is deprecated.
---
 src/borg/archiver.py | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/src/borg/archiver.py b/src/borg/archiver.py
index 5df8cc1be..f6a6bcc79 100644
--- a/src/borg/archiver.py
+++ b/src/borg/archiver.py
@@ -3242,6 +3242,8 @@ class Archiver:
                 group.add_argument('--last', metavar='N', dest='last', default=0, type=positive_int_validator,
                                    help='consider last N archives after other filters were applied')
 
+            return filters_group
+
         def define_borg_mount(parser):
             parser.set_defaults(func=self.do_mount)
             parser.add_argument('--consider-checkpoints', action='store_true', dest='consider_checkpoints',
@@ -4982,8 +4984,7 @@ class Archiver:
 
         define_exclusion_group(subparser, tag_files=True)
 
-        archive_group = subparser.add_argument_group('Archive options')
-        define_archive_filters_group(archive_group)
+        archive_group = define_archive_filters_group(subparser)
         archive_group.add_argument('--target', dest='target', metavar='TARGET', default=None,
                                    type=archivename_validator(),
                                    help='create a new archive with the name ARCHIVE, do not replace existing archive '

From 31a081f6958aa89004c8c6ab95879ac55d14ff3a Mon Sep 17 00:00:00 2001
From: Thomas Waldmann <tw@waldmann-edv.de>
Date: Thu, 23 Jun 2022 14:13:19 +0200
Subject: [PATCH 069/160] simplify stats output

also:
- move stats related stuff to Statistics class
- repo ops give repo / overall stats
- archive ops give archive stats
- adapt tests
---
 src/borg/archive.py            | 17 ++++++--------
 src/borg/archiver.py           | 42 ++++++++++------------------------
 src/borg/cache.py              |  9 ++++----
 src/borg/testsuite/archive.py  | 14 ++++++++----
 src/borg/testsuite/archiver.py |  7 +++---
 5 files changed, 36 insertions(+), 53 deletions(-)

diff --git a/src/borg/archive.py b/src/borg/archive.py
index f9dd2e486..016544da6 100644
--- a/src/borg/archive.py
+++ b/src/borg/archive.py
@@ -84,10 +84,12 @@ class Statistics:
         stats.nfiles_parts = self.nfiles_parts + other.nfiles_parts
         return stats
 
-    summary = "{label:15} {stats.osize_fmt:>20s} {stats.usize_fmt:>20s}"
-
     def __str__(self):
-        return self.summary.format(stats=self, label='This archive:')
+        return """\
+Number of files: {stats.nfiles}
+Original size: {stats.osize_fmt}
+Deduplicated size: {stats.usize_fmt}
+""".format(stats=self)
 
     def __repr__(self):
         return "<{cls} object at {hash:#x} ({self.osize}, {self.usize})>".format(
@@ -538,7 +540,6 @@ Archive fingerprint: {0.fpr}
 Time (start): {start}
 Time (end):   {end}
 Duration: {0.duration}
-Number of files: {0.stats.nfiles}
 Utilization of max. archive size: {csize_max:.0%}
 '''.format(
             self,
@@ -2141,12 +2142,8 @@ class ArchiveRecreater:
         if self.stats:
             target.start = _start
             target.end = datetime.utcnow()
-            log_multi(DASHES,
-                      str(target),
-                      DASHES,
-                      str(target.stats),
-                      str(self.cache),
-                      DASHES)
+            log_multi(str(target),
+                      str(target.stats))
 
     def matcher_add_tagged_dirs(self, archive):
         """Add excludes to the matcher created by exclude_cache and exclude_if_present."""
diff --git a/src/borg/archiver.py b/src/borg/archiver.py
index f6a6bcc79..8218ca1cf 100644
--- a/src/borg/archiver.py
+++ b/src/borg/archiver.py
@@ -993,13 +993,9 @@ class Archiver:
                                 'archive': archive,
                             }))
                         else:
-                            log_multi(DASHES,
-                                      str(archive),
-                                      DASHES,
-                                      STATS_HEADER,
+                            log_multi(str(archive),
                                       str(archive.stats),
-                                      str(cache),
-                                      DASHES, logger=logging.getLogger('borg.output.stats'))
+                                      logger=logging.getLogger('borg.output.stats'))
 
         self.output_filter = args.output_filter
         self.output_list = args.output_list
@@ -1643,11 +1639,8 @@ class Archiver:
                 repository.commit(compact=False, save_space=args.save_space)
                 cache.commit()
             if args.stats:
-                log_multi(DASHES,
-                          STATS_HEADER,
-                          stats.summary.format(label='Deleted data:', stats=stats),
-                          str(cache),
-                          DASHES, logger=logging.getLogger('borg.output.stats'))
+                log_multi(str(stats),
+                          logger=logging.getLogger('borg.output.stats'))
 
         return self.exit_code
 
@@ -1767,8 +1760,6 @@ class Archiver:
                 id=bin_to_hex(repository.id),
                 location=repository._location.canonical_path(),
                 **info))
-            print(DASHES)
-            print(STATS_HEADER)
             print(str(cache))
         return self.exit_code
 
@@ -1801,14 +1792,12 @@ class Archiver:
                 Time (start): {start}
                 Time (end): {end}
                 Duration: {duration}
-                Number of files: {stats[nfiles]}
                 Command line: {command_line}
                 Utilization of maximum supported archive size: {limits[max_archive_size]:.0%}
-                ------------------------------------------------------------------------------
-                                       Original size    Deduplicated size
-                This archive:   {stats[original_size]:>20s} {stats[deduplicated_size]:>20s}
-                {cache}
-                """).strip().format(cache=cache, **info))
+                Number of files: {stats[nfiles]}
+                Original size: {stats[original_size]}
+                Deduplicated size: {stats[deduplicated_size]}
+                """).strip().format(**info))
             if self.exit_code:
                 break
             if not args.json and len(archive_names) - i:
@@ -1899,11 +1888,8 @@ class Archiver:
                 repository.commit(compact=False, save_space=args.save_space)
                 cache.commit()
             if args.stats:
-                log_multi(DASHES,
-                          STATS_HEADER,
-                          stats.summary.format(label='Deleted data:', stats=stats),
-                          str(cache),
-                          DASHES, logger=logging.getLogger('borg.output.stats'))
+                log_multi(str(stats),
+                          logger=logging.getLogger('borg.output.stats'))
         return self.exit_code
 
     @with_repository(fake=('tam', 'disable_tam'), invert_fake=True, manifest=False, exclusive=True)
@@ -2066,13 +2052,9 @@ class Archiver:
                     'archive': archive,
                 }))
             else:
-                log_multi(DASHES,
-                          str(archive),
-                          DASHES,
-                          STATS_HEADER,
+                log_multi(str(archive),
                           str(archive.stats),
-                          str(archive.cache),
-                          DASHES, logger=logging.getLogger('borg.output.stats'))
+                          logger=logging.getLogger('borg.output.stats'))
 
     @with_repository(manifest=False, exclusive=True)
     def do_with_lock(self, args, repository):
diff --git a/src/borg/cache.py b/src/borg/cache.py
index 2c84b754e..5addd34e1 100644
--- a/src/borg/cache.py
+++ b/src/borg/cache.py
@@ -405,10 +405,11 @@ class Cache:
 
 class CacheStatsMixin:
     str_format = """\
-All archives:   {0.total_size:>20s} {0.unique_size:>20s}
-
-                       Unique chunks         Total chunks
-Chunk index:    {0.total_unique_chunks:20d} {0.total_chunks:20d}"""
+Original size: {0.total_size}
+Deduplicated size: {0.unique_size}
+Unique chunks: {0.total_unique_chunks}
+Total chunks: {0.total_chunks}
+"""
 
     def __init__(self, iec=False):
         self.iec = iec
diff --git a/src/borg/testsuite/archive.py b/src/borg/testsuite/archive.py
index 6bfb933ab..cf19a5821 100644
--- a/src/borg/testsuite/archive.py
+++ b/src/borg/testsuite/archive.py
@@ -20,6 +20,7 @@ from ..platform import uid2user, gid2group
 def stats():
     stats = Statistics()
     stats.update(20, unique=True)
+    stats.nfiles = 1
     return stats
 
 
@@ -35,26 +36,29 @@ def tests_stats_progress(stats, monkeypatch, columns=80):
     monkeypatch.setenv('COLUMNS', str(columns))
     out = StringIO()
     stats.show_progress(stream=out)
-    s = '20 B O 20 B U 0 N '
+    s = '20 B O 20 B U 1 N '
     buf = ' ' * (columns - len(s))
     assert out.getvalue() == s + buf + "\r"
 
     out = StringIO()
     stats.update(10 ** 3, unique=False)
     stats.show_progress(item=Item(path='foo'), final=False, stream=out)
-    s = '1.02 kB O 20 B U 0 N foo'
+    s = '1.02 kB O 20 B U 1 N foo'
     buf = ' ' * (columns - len(s))
     assert out.getvalue() == s + buf + "\r"
     out = StringIO()
     stats.show_progress(item=Item(path='foo'*40), final=False, stream=out)
-    s = '1.02 kB O 20 B U 0 N foofoofoofoofoofoofoofoofo...foofoofoofoofoofoofoofoofoofoo'
+    s = '1.02 kB O 20 B U 1 N foofoofoofoofoofoofoofoofo...foofoofoofoofoofoofoofoofoofoo'
     buf = ' ' * (columns - len(s))
     assert out.getvalue() == s + buf + "\r"
 
 
 def test_stats_format(stats):
     assert str(stats) == """\
-This archive:                   20 B                 20 B"""
+Number of files: 1
+Original size: 20 B
+Deduplicated size: 20 B
+"""
     s = f"{stats.osize_fmt}"
     assert s == "20 B"
     # kind of redundant, but id is variable so we can't match reliably
@@ -72,7 +76,7 @@ def test_stats_progress_json(stats):
     assert result['finished'] is False
     assert result['path'] == 'foo'
     assert result['original_size'] == 20
-    assert result['nfiles'] == 0  # this counter gets updated elsewhere
+    assert result['nfiles'] == 1
 
     out = StringIO()
     stats.show_progress(stream=out, final=True)
diff --git a/src/borg/testsuite/archiver.py b/src/borg/testsuite/archiver.py
index ef22bf58b..a3907c2c9 100644
--- a/src/borg/testsuite/archiver.py
+++ b/src/borg/testsuite/archiver.py
@@ -397,7 +397,6 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self.cmd(f'--repo={self.repository_location}', 'create', '--exclude-nodump', 'test', 'input')
         output = self.cmd(f'--repo={self.repository_location}', 'create', '--exclude-nodump', '--stats', 'test.2', 'input')
         self.assert_in('Archive name: test.2', output)
-        self.assert_in('This archive: ', output)
         with changedir('output'):
             self.cmd(f'--repo={self.repository_location}', 'extract', 'test')
         list_output = self.cmd(f'--repo={self.repository_location}', 'rlist', '--short')
@@ -1525,7 +1524,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
         self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
         info_repo = self.cmd(f'--repo={self.repository_location}', 'rinfo')
-        assert 'All archives:' in info_repo
+        assert 'Original size:' in info_repo
         info_archive = self.cmd(f'--repo={self.repository_location}', 'info', '-a', 'test')
         assert 'Archive name: test\n' in info_archive
         info_archive = self.cmd(f'--repo={self.repository_location}', 'info', '--first', '1')
@@ -1604,7 +1603,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self.cmd(f'--repo={self.repository_location}', 'delete', '-a', 'test')
         self.cmd(f'--repo={self.repository_location}', 'extract', 'test.2', '--dry-run')
         output = self.cmd(f'--repo={self.repository_location}', 'delete', '-a', 'test.2', '--stats')
-        self.assert_in('Deleted data:', output)
+        self.assert_in('Original size: -', output)  # negative size == deleted data
         # Make sure all data except the manifest has been deleted
         with Repository(self.repository_path) as repository:
             self.assert_equal(len(repository), 1)
@@ -3514,7 +3513,7 @@ id: 2 / e29442 3506da 4e1ea7 / 25f62a 5a3d41 - 02
 
         # The repo should still be readable
         repo_info = self.cmd(f'--repo={self.repository_location}', 'rinfo')
-        assert 'All archives:' in repo_info
+        assert 'Original size:' in repo_info
         repo_list = self.cmd(f'--repo={self.repository_location}', 'rlist')
         assert 'test' in repo_list
         # The archive should still be readable

From 7f99aa155e301bcf3abd6ab190a9e86ce6475b14 Mon Sep 17 00:00:00 2001
From: Thomas Waldmann <tw@waldmann-edv.de>
Date: Fri, 24 Jun 2022 00:28:18 +0200
Subject: [PATCH 070/160] update CHANGES, split changelog by major version

---
 docs/changes.rst     | 5228 +-----------------------------------------
 docs/changes_0.x.rst |  807 +++++++
 docs/changes_1.x.rst | 4362 +++++++++++++++++++++++++++++++++++
 docs/index.rst       |    2 +
 4 files changed, 5283 insertions(+), 5116 deletions(-)
 create mode 100644 docs/changes_0.x.rst
 create mode 100644 docs/changes_1.x.rst

diff --git a/docs/changes.rst b/docs/changes.rst
index a0ca5d4fb..e6ac6bc1d 100644
--- a/docs/changes.rst
+++ b/docs/changes.rst
@@ -1,228 +1,127 @@
 .. _important_notes:
 
-Important notes
-===============
+Important notes 2.x
+===================
 
 This section provides information about security and corruption issues.
 
-.. _hashindex_set_bug:
-
-Pre-1.1.11 potential index corruption / data loss issue
--------------------------------------------------------
-
-A bug was discovered in our hashtable code, see issue #4829.
-The code is used for the client-side chunks cache and the server-side repo index.
-
-Although borg uses the hashtables very heavily, the index corruption did not
-happen too frequently, because it needed specific conditions to happen.
-
-Data loss required even more specific conditions, so it should be rare (and
-also detectable via borg check).
-
-You might be affected if borg crashed with / complained about:
-
-- AssertionError: Corrupted segment reference count - corrupted index or hints
-- ObjectNotFound: Object with key ... not found in repository ...
-- Index mismatch for key b'...'. (..., ...) != (-1, -1)
-- ValueError: stats_against: key contained in self but not in master_index.
-
-Advised procedure to fix any related issue in your indexes/caches:
-
-- install fixed borg code (on client AND server)
-- for all of your clients and repos remove the cache by:
-
-  borg delete --cache-only YOURREPO
-
-  (later, the cache will be re-built automatically)
-- for all your repos, rebuild the repo index by:
-
-  borg check --repair YOURREPO
-
-  This will also check all archives and detect if there is any data-loss issue.
-
-Affected branches / releases:
-
-- fd06497 introduced the bug into 1.1-maint branch - it affects all borg 1.1.x since 1.1.0b4.
-- fd06497 introduced the bug into master branch - it affects all borg 1.2.0 alpha releases.
-- c5cd882 introduced the bug into 1.0-maint branch - it affects all borg 1.0.x since 1.0.11rc1.
-
-The bug was fixed by:
-
-- 701159a fixes the bug in 1.1-maint branch - will be released with borg 1.1.11.
-- fa63150 fixes the bug in master branch - will be released with borg 1.2.0a8.
-- 7bb90b6 fixes the bug in 1.0-maint branch. Branch is EOL, no new release is planned as of now.
-
-.. _broken_validator:
-
-Pre-1.1.4 potential data corruption issue
------------------------------------------
-
-A data corruption bug was discovered in borg check --repair, see issue #3444.
-
-This is a 1.1.x regression, releases < 1.1 (e.g. 1.0.x) are not affected.
-
-To avoid data loss, you must not run borg check --repair using an unfixed version
-of borg 1.1.x. The first official release that has the fix is 1.1.4.
-
-Package maintainers may have applied the fix to updated packages of 1.1.x (x<4)
-though, see the package maintainer's package changelog to make sure.
-
-If you never had missing item metadata chunks, the bug has not affected you
-even if you did run borg check --repair with an unfixed version.
-
-When borg check --repair tried to repair corrupt archives that miss item metadata
-chunks, the resync to valid metadata in still present item metadata chunks
-malfunctioned. This was due to a broken validator that considered all (even valid)
-item metadata as invalid. As they were considered invalid, borg discarded them.
-Practically, that means the affected files, directories or other fs objects were
-discarded from the archive.
-
-Due to the malfunction, the process was extremely slow, but if you let it
-complete, borg would have created a "repaired" archive that has lost a lot of items.
-If you interrupted borg check --repair because it was so strangely slow (killing
-borg somehow, e.g. Ctrl-C) the transaction was rolled back and no corruption occurred.
-
-The log message indicating the precondition for the bug triggering looks like:
-
-    item metadata chunk missing [chunk: 001056_bdee87d...a3e50d]
-
-If you never had that in your borg check --repair runs, you're not affected.
-
-But if you're unsure or you actually have seen that, better check your archives.
-By just using "borg list repo::archive" you can see if all expected filesystem
-items are listed.
-
-.. _tam_vuln:
-
-Pre-1.0.9 manifest spoofing vulnerability (CVE-2016-10099)
-----------------------------------------------------------
-
-A flaw in the cryptographic authentication scheme in Borg allowed an attacker
-to spoof the manifest. The attack requires an attacker to be able to
-
-1. insert files (with no additional headers) into backups
-2. gain write access to the repository
-
-This vulnerability does not disclose plaintext to the attacker, nor does it
-affect the authenticity of existing archives.
-
-The vulnerability allows an attacker to create a spoofed manifest (the list of archives).
-Creating plausible fake archives may be feasible for small archives, but is unlikely
-for large archives.
-
-The fix adds a separate authentication tag to the manifest. For compatibility
-with prior versions this authentication tag is *not* required by default
-for existing repositories. Repositories created with 1.0.9 and later require it.
-
-Steps you should take:
-
-1. Upgrade all clients to 1.0.9 or later.
-2. Run ``borg upgrade --tam <repository>`` *on every client* for *each* repository.
-3. This will list all archives, including archive IDs, for easy comparison with your logs.
-4. Done.
-
-Prior versions can access and modify repositories with this measure enabled, however,
-to 1.0.9 or later their modifications are indiscernible from an attack and will
-raise an error until the below procedure is followed. We are aware that this can
-be annoying in some circumstances, but don't see a way to fix the vulnerability
-otherwise.
-
-In case a version prior to 1.0.9 is used to modify a repository where above procedure
-was completed, and now you get an error message from other clients:
-
-1. ``borg upgrade --tam --force <repository>`` once with *any* client suffices.
-
-This attack is mitigated by:
-
-- Noting/logging ``borg list``, ``borg info``, or ``borg create --stats``, which
-  contain the archive IDs.
-
-We are not aware of others having discovered, disclosed or exploited this vulnerability.
-
-Vulnerability time line:
-
-* 2016-11-14: Vulnerability and fix discovered during review of cryptography by Marian Beermann (@enkore)
-* 2016-11-20: First patch
-* 2016-12-20: Released fixed version 1.0.9
-* 2017-01-02: CVE was assigned
-* 2017-01-15: Released fixed version 1.1.0b3 (fix was previously only available from source)
-
-.. _attic013_check_corruption:
-
-Pre-1.0.9 potential data loss
------------------------------
-
-If you have archives in your repository that were made with attic <= 0.13
-(and later migrated to borg), running borg check would report errors in these
-archives. See issue #1837.
-
-The reason for this is a invalid (and useless) metadata key that was
-always added due to a bug in these old attic versions.
-
-If you run borg check --repair, things escalate quickly: all archive items
-with invalid metadata will be killed. Due to that attic bug, that means all
-items in all archives made with these old attic versions.
-
-
-Pre-1.0.4 potential repo corruption
------------------------------------
-
-Some external errors (like network or disk I/O errors) could lead to
-corruption of the backup repository due to issue #1138.
-
-A sign that this happened is if "E" status was reported for a file that can
-not be explained by problems with the source file. If you still have logs from
-"borg create -v --list", you can check for "E" status.
-
-Here is what could cause corruption and what you can do now:
-
-1) I/O errors (e.g. repo disk errors) while writing data to repo.
-
-This could lead to corrupted segment files.
-
-Fix::
-
-    # check for corrupt chunks / segments:
-    borg check -v --repository-only REPO
-
-    # repair the repo:
-    borg check -v --repository-only --repair REPO
-
-    # make sure everything is fixed:
-    borg check -v --repository-only REPO
-
-2) Unreliable network / unreliable connection to the repo.
-
-This could lead to archive metadata corruption.
-
-Fix::
-
-    # check for corrupt archives:
-    borg check -v --archives-only REPO
-
-    # delete the corrupt archives:
-    borg delete --force REPO::CORRUPT_ARCHIVE
-
-    # make sure everything is fixed:
-    borg check -v --archives-only REPO
-
-3) In case you want to do more intensive checking.
-
-The best check that everything is ok is to run a dry-run extraction::
-
-    borg extract -v --dry-run REPO::ARCHIVE
+(nothing to see here yet)
 
 .. _changelog:
 
-Change Log
-==========
+Change Log 2.x
+==============
+
+Version 2.0.0a2 (not released yet)
+----------------------------------
+
+Please note:
+
+This is an alpha release, only for testing - do not use for production repos.
+
+Compatibility notes:
+
+- this is a major "breaking" release that is not compatible with existing repos.
+
+  We tried to put all the necessary "breaking" changes into this release, so we
+  hopefully do not need another breaking release in the near future. The changes
+  were necessary for improved security, improved speed, unblocking future
+  improvements, getting rid of legacy crap / design limitations, having less and
+  simpler code to maintain.
+
+  You can use "borg transfer" to transfer archives from borg 1.1/1.2 repos to
+  a new borg 2.0 repo, but it will need some time and space.
+
+- command line syntax was changed, scripts and wrappers will need changes:
+
+  - you will usually either export BORG_REPO=<MYREPO> into your environment or
+    call borg like: borg -r <MYREPO> command (-r ... usually omitted for brevity)
+  - the scp-style REPO syntax was removed, please use ssh://..., #6697
+  - differently than with borg 1.x you ONLY give the repo there, never a ::archive.
+  - the archive name is either given as a positional parameter, like:
+
+    - borg create myarchive2 /some/path
+    - borg diff myarchive1 myarchive2
+  - or, if the command makes sense for an arbitrary amount of archives, archives
+    can be selected using a glob pattern, like:
+
+    - borg delete -a 'myarchive*'
+    - borg recreate -a 'myarchive*'
+  - some borg 1.x commands that supported working on a repo AND on an archive
+    were split into 2 commands, some others were renamed:
+
+    - borg 2 repo commands:
+
+      - borg rcreate  # "repo create", was: borg init
+      - borg rlist  # "repo list"
+      - borg rinfo  # "repo info"
+      - borg rdelete  # "repo delete"
+
+    - borg 2 archive commands:
+
+      - borg create ARCHIVE ...
+      - borg list ARCHIVE
+      - borg info -a ARCH_GLOB
+      - borg delete -a ARCH_GLOB
+      - borg diff ARCH1 ARCH2
+      - borg extract ARCHIVE ...
+      - borg recreate -a ARCH_GLOB ...
+      - borg rename OLDNAME NEWNAME
+      - borg mount -a ARCH_GLOB mountpoint ...
+
+    For more details, please consult the docs or --help option output.
+
+Changes:
+
+- split repo and archive name into separate args, #948
+
+  - use -r or --repo or BORG_REPO env var to give the repository
+  - use --other-repo or BORG_OTHER_REPO to give another repo (e.g. borg transfer)
+  - use positional argument for archive name or `-a ARCH_GLOB`
+
+- remove support for scp-style repo specification, use ssh://...
+- simplify stats output: repo ops -> repo stats, archive ops -> archive stats
+
+- repository index: add payload size (==csize) and flags to NSIndex entries
+- repository index: set/query flags, iteration over flagged items (NSIndex)
+- repository: sync write file in get_fd
+
+- stats: deduplicated size now, was deduplicated compressed size in borg 1.x
+- remove csize support at most places in the code (chunks index, stats, get_size,
+  Item.chunks)
+
+- replace problematic/ugly hardlink_master approach of borg 1.x by:
+
+  - symmetric hlid (all hardlinks pointing to same inode have same hlid)
+  - all archived hardlinked regular files have a chunks list
+
+- borg init --other-repo=OTHER_REPO: reuse key material from OTHER_REPO, #6554
+- borg transfer:
+
+  - efficiently copy archives from borg 1.1/1.2 repo to new repo. uses
+    deduplication and does not decompress/recompress file content data.
+  - does some cleanups / fixes / conversions:
+
+    - disallow None value for .user/group/chunks/chunks_healthy
+    - cleanup msgpack related str/bytes mess, use new msgpack spec, #968
+    - obfuscation: fix byte order for size, #6701
+    - compression: use the 2 bytes for type and level, #6698
+    - use version 2 for new archives
+    - convert timestamps int/bigint -> msgpack.Timestamp, see #2323
+    - all hardlinks have chunks, maybe chunks_healty, hlid
+    - remove the zlib type bytes hack
+    - make sure items with chunks have precomputed size
+    - clean item of attic 0.13 'acl' bug remnants
+
+- crypto: see 1.3.0a1 log entry
+
 
 Version 1.3.0a1 (2022-04-15)
 ----------------------------
 
-Please note:
-
-This is an alpha release, only for testing - do not use this with production repos.
+Although this was released as 1.3.0a1, it can be also seen as 2.0.0a1 as it was
+later decided to do breaking changes and thus the major release number had to
+be increased (thus, there will not be a 1.3.0 release, but 2.0.0).
 
 New features:
 
@@ -261,4906 +160,3 @@ Other changes:
 - OpenBSD: build borg with OpenSSL (not: LibreSSL), #6474
 - remove support for LibreSSL, #6474
 - remove support for OpenSSL < 1.1.1
-
-
-Version 1.2.0 (2022-02-22 22:02:22 :-)
---------------------------------------
-
-Please note:
-
-This is the first borg 1.2 release, so be careful and read the notes below.
-
-Upgrade notes:
-
-Strictly taken, nothing special is required for upgrading to 1.2, but some
-things can be recommended:
-
-- do you already want to upgrade? 1.1.x also will get fixes for a while.
-- be careful, first upgrade your less critical / smaller repos.
-- first upgrade to a recent 1.1.x release - especially if you run some older
-  1.1.* or even 1.0.* borg release.
-- using that, run at least one `borg create` (your normal backup), `prune`
-  and especially a `check` to see everything is in a good state.
-- check the output of `borg check` - if there is anything special, consider
-  a `borg check --repair` followed by another `borg check`.
-- if everything is fine so far (borg check reports no issues), you can consider
-  upgrading to 1.2.0. if not, please first fix any already existing issue.
-- if you want to play safer, first **create a backup of your borg repository**.
-- upgrade to latest borg 1.2.x release (you could use the fat binary from
-  github releases page)
-- run `borg compact --cleanup-commits` to clean up a ton of 17 bytes long files
-  in your repo caused by a borg 1.1 bug
-- run `borg check` again (now with borg 1.2.x) and check if there is anything
-  special.
-- run `borg info` (with borg 1.2.x) to build the local pre12-meta cache (can
-  take significant time, but after that it will be fast) - for more details
-  see below.
-- check the compatibility notes (see below) and adapt your scripts, if needed.
-- if you run into any issues, please check the github issue tracker before
-  posting new issues there or elsewhere.
-
-If you follow this procedure, you can help avoiding that we get a lot of
-"borg 1.2" issue reports that are not really 1.2 issues, but existed before
-and maybe just were not noticed.
-
-Compatibility notes:
-
-- matching of path patterns has been aligned with borg storing relative paths.
-  Borg archives file paths without leading slashes. Previously, include/exclude
-  patterns could contain leading slashes. You should check your patterns and
-  remove leading slashes.
-- dropped support / testing for older Pythons, minimum requirement is 3.8.
-  In case your OS does not provide Python >= 3.8, consider using our binary,
-  which does not need an external Python interpreter. Or continue using
-  borg 1.1.x, which is still supported.
-- freeing repository space only happens when "borg compact" is invoked.
-- mount: the default for --numeric-ids is False now (same as borg extract)
-- borg create --noatime is deprecated. Not storing atime is the default behaviour
-  now (use --atime if you want to store the atime).
-- list: corrected mix-up of "isomtime" and "mtime" formats.
-  Previously, "isomtime" was the default but produced a verbose human format,
-  while "mtime" produced a ISO-8601-like format.
-  The behaviours have been swapped (so "mtime" is human, "isomtime" is ISO-like),
-  and the default is now "mtime".
-  "isomtime" is now a real ISO-8601 format ("T" between date and time, not a space).
-- create/recreate --list: file status for all files used to get announced *AFTER*
-  the file (with borg < 1.2). Now, file status is announced *BEFORE* the file
-  contents are processed. If the file status changes later (e.g. due to an error
-  or a content change), the updated/final file status will be printed again.
-- removed deprecated-since-long stuff (deprecated since):
-
-  - command "borg change-passphrase" (2017-02), use "borg key ..."
-  - option "--keep-tag-files" (2017-01), use "--keep-exclude-tags"
-  - option "--list-format" (2017-10), use "--format"
-  - option "--ignore-inode" (2017-09), use "--files-cache" w/o "inode"
-  - option "--no-files-cache" (2017-09), use "--files-cache=disabled"
-- removed BORG_HOSTNAME_IS_UNIQUE env var.
-  to use borg you must implement one of these 2 scenarios:
-
-  - 1) the combination of FQDN and result of uuid.getnode() must be unique
-       and stable (this should be the case for almost everybody, except when
-       having duplicate FQDN *and* MAC address or all-zero MAC address)
-  - 2) if you are aware that 1) is not the case for you, you must set
-       BORG_HOST_ID env var to something unique.
-- exit with 128 + signal number, #5161.
-  if you have scripts expecting rc == 2 for a signal exit, you need to update
-  them to check for >= 128.
-
-Fixes:
-
-- diff: reduce memory consumption, fix is_hardlink_master, #6295
-- compact: fix / improve freeable / freed space log output
-
-  - derive really freed space from quota use before/after, #5679
-  - do not say "freeable", but "maybe freeable" (based on hint, unsure)
-- fix race conditions in internal SaveFile function, #6306 #6028
-- implement internal safe_unlink (was: truncate_and_unlink) function more safely:
-  usually it does not truncate any more, only under "disk full" circumstances
-  and only if there is only one hardlink.
-  see: https://github.com/borgbackup/borg/discussions/6286
-
-Other changes:
-
-- info: use a pre12-meta cache to accelerate stats for borg < 1.2 archives.
-  the first time borg info is invoked on a borg 1.1 repo, it can take a
-  rather long time computing and caching some stats values for 1.1 archives,
-  which borg 1.2 archives have in their archive metadata structure.
-  be patient, esp. if you have lots of old archives.
-  following invocations are much faster due to the cache.
-  related change: add archive name to calc_stats progress display.
-- docs:
-
-  - add borg 1.2 upgrade notes, #6217
-  - link to borg placeholders and borg patterns help
-  - init: explain the encryption modes better
-  - clarify usage of patternfile roots
-  - put import-tar docs into same file as export-tar docs
-  - explain the difference between a path that ends with or without a slash,
-    #6297
-
-
-Version 1.2.0rc1 (2022-02-05)
------------------------------
-
-Fixes:
-
-- repo::archive location placeholder expansion fixes, #5826, #5998
-- repository: fix intermediate commits, shall be at end of current segment
-- delete: don't commit if nothing was deleted, avoid cache sync, #6060
-- argument parsing: accept some options only once, #6026
-- disallow overwriting of existing keyfiles on init, #6036
-- if ensure_dir() fails, give more informative error message, #5952
-
-New features:
-
-- delete --force: do not ask when deleting a repo, #5941
-
-Other changes:
-
-- requirements: exclude broken or incompatible-with-pyinstaller setuptools
-- add a requirements.d/development.lock.txt and use it for vagrant
-- tests:
-
-  - added nonce-related tests
-  - refactor: remove assert_true
-  - vagrant: macos box tuning, netbsd box fixes, #5370, #5922
-- docs:
-
-  - update install docs / requirements docs, #6180
-  - borg mount / FUSE "versions" view is not experimental any more
-  - --pattern* is not experimental any more, #6134
-  - impact of deleting path/to/repo/nonce, #5858
-  - key export: add examples, #6204
-  - ~/.config/borg/keys is not used for repokey keys, #6107
-  - excluded parent dir's metadata can't restore
-
-
-Version 1.2.0b4 (2022-01-23)
-----------------------------
-
-Fixes:
-
-- create: fix passing device nodes and symlinks to --paths-from-stdin, #6009
-- create --dry-run: fix display of kept tagfile, #5834
-- check --repair: fix missing parameter in "did not consistently fail" msg, #5822
-- fix hardlinkable file type check, #6037
-- list: remove placeholders for shake_* hashes, #6082
-- prune: handle case of calling prune_split when there are no archives, #6015
-- benchmark crud: make sure cleanup of borg-test-data files/dir happens, #5630
-- do not show archive name in repository-related error msgs, #6014
-- prettier error msg (no stacktrace) if exclude file is missing, #5734
-- do not require BORG_CONFIG_DIR if BORG_{SECURITY,KEYS}_DIR are set, #5979
-- fix pyinstaller detection for dir-mode, #5897
-- atomically create the CACHE_TAG file, #6028
-- deal with the SaveFile/SyncFile race, docs, see #6056 708a5853
-- avoid expanding path into LHS of formatting operation + tests, #6064 #6063
-- repository: quota / compactable computation fixes
-- info: emit repo info even if repo has 0 archives + test, #6120
-
-New features:
-
-- check --repair: significantly speed up search for next valid object in segment, #6022
-- check: add progress indicator for archive check, #5809
-- create: add retry_erofs workaround for O_NOATIME issue on volume shadow copies in WSL1, #6024
-- create: allow --files-cache=size (this is potentially dangerous, use on your own risk), #5686
-- import-tar: implement import-tar to complement export-tar, #2233
-- implement BORG_SELFTEST env variable (can be carefully used to speedup borg hosting), #5871
-- key export: print key if path is '-' or not given, #6092
-- list --format: Add command_line to format keys
-
-Other changes:
-
-- pypi metadata: alpha -> beta
-- require python 3.8+, #5975
-- use pyinstaller 4.7
-- allow msgpack 1.0.3
-- upgrade to bundled xxhash to 0.8.1
-- import-tar / export-tar: tar file related changes:
-
-  - check for short tarfile extensions
-  - add .lz4 and .zstd
-  - fix docs about extensions and decompression commands
-- add github codeql analysis, #6148
-- vagrant:
-
-  - box updates / add new boxes / remove outdated and broken boxes
-  - use Python 3.9.10 (incl. binary builds) and 3.10.0
-  - fix pyenv initialisation, #5798
-  - fix vagrant scp on macOS, #5921
-  - use macfuse instead of osxfuse
-- shell completions:
-
-  - update shell completions to 1.1.17, #5923
-  - remove BORG_LIBC completion, since 9914968 borg no longer uses find_library().
-- docs:
-
-  - fixed readme.rst irc webchat link (we use libera chat now, not freenode)
-  - fix exceptions thrown by `setup.py build_man`
-  - check --repair: recommend checking hw before check --repair, #5855
-  - check --verify-data: clarify and document conflict with --repository-only, #5808
-  - serve: improve ssh forced commands docs, #6083
-  - list: improve docs for `borg list` --format, #6061
-  - list: remove --list-format from borg list
-  - FAQ: fix manifest-timestamp path (inside security dir)
-  - fix the broken link to .nix file
-  - document behavior for filesystems with inconsistent inodes, #5770
-  - clarify user_id vs uid for fuse, #5723
-  - clarify pattern usage with commands, #5176
-  - clarify pp vs. pf pattern type, #5300
-  - update referenced freebsd/macOS versions used for binary build, #5942
-  - pull mode: add some warnings, #5827
-  - clarify "you will need key and passphrase" borg init warning, #4622
-  - add missing leading slashes in help patterns, #5857
-  - add info on renaming repositories, #5240
-  - check: add notice about defective hardware, #5753
-  - mention tar --compare (compare archive to fs files), #5880
-  - add note about grandfather-father-son backup retention policy / rotation scheme, #6006
-  - permissions note rewritten to make it less confusing
-  - create github security policy
-  - remove leftovers of BORG_HOSTNAME_IS_UNIQUE
-  - excluded parent dir's metadata can't restore. (#6062)
-  - if parent dir is not extracted, we do not have its metadata
-  - clarify who starts the remote agent
-
-
-Version 1.2.0b3 (2021-05-12)
-----------------------------
-
-Fixes:
-
-- create: fix --progress --log-json, #4360#issuecomment-774580052
-- do not load files cache for commands not using it, #5673
-- fix repeated cache tag file writing bug
-
-New features:
-
-- create/recreate: print preliminary file status early, #5417
-- create/extract: add --noxattrs and --noacls options, #3955
-- create: verbose files cache logging via --debug-topic=files_cache, #5659
-- mount: implement --numeric-ids (default: False!), #2377
-- diff: add --json-lines option
-- info / create --stats: add --iec option to print sizes in powers of 1024.
-
-Other changes:
-
-- create: add --upload-(ratelimit|buffer), deprecate --remote-* options, #5611
-- create/extract/mount: add --numeric-ids, deprecate --numeric-owner option, #5724
-- config: accept non-int value for max_segment_size / storage_quota
-- use PyInstaller v4.3, #5671
-- vagrant: use Python 3.9.5 to build binaries
-- tox.ini: modernize and enable execution without preinstalling deps
-- cleanup code style checks
-- get rid of distutils, use setuptools+packaging
-- github CI: test on Python 3.10-dev
-- check: missing / healed chunks: always tell chunk ID, #5704
-- docs:
-
-  - remove bad /var/cache exclusion in example commands, #5625
-  - misc. fixes and improvements, esp. for macOS
-  - add unsafe workaround to use an old repo copy, #5722
-
-
-Version 1.2.0b2 (2021-02-06)
-----------------------------
-
-Fixes:
-
-- create: do not recurse into duplicate roots, #5603
-- create: only print stats if not ctrl-c'ed, fixes traceback, #5668
-- extract:
-  improve exception handling when setting xattrs, #5092.
-  emit a warning message giving the path, xattr key and error message.
-  continue trying to restore other xattrs and bsdflags of the same file
-  after an exception with xattr-setting happened.
-- export-tar:
-  fix memory leak with ssh: remote repository, #5568.
-  fix potential memory leak with ssh: remote repository with partial extraction.
-- remove empty shadowed_segments lists, #5275
-- fix bad default: manifest.archives.list(consider_checkpoints=False),
-  fixes tracebacks / KeyErros for missing objects in ChunkIndex, #5668
-
-New features:
-
-- create: improve sparse file support
-
-  - create --sparse (detect sparse file holes) and file map support,
-    only for the "fixed" chunker, #14
-  - detect all-zero chunks in read data in "buzhash" and "fixed" chunkers
-  - cached_hash: use a small LRU cache to accelerate all-zero chunks hashing
-  - use cached_hash also to generate all-zero replacement chunks
-- create --remote-buffer, add a upload buffer for remote repos, #5574
-- prune: keep oldest archive when retention target not met
-
-Other changes:
-
-- use blake2 from python 3.6+ hashlib
-  (this removes the requirement for libb2 and the bundled blake2 code)
-- also accept msgpack up to 1.0.2.
-  exclude 1.0.1 though, which had some issues (not sure they affect borg).
-- create: add repository location to --stats output, #5491
-- check: debug log the segment filename
-- delete: add a --list switch to borg delete, #5116
-- borg debug dump-hints - implemented to e.g. to look at shadow_index
-- Tab completion support for additional archives for 'borg delete'
-- refactor: have one borg.constants.zero all-zero bytes object
-- refactor shadow_index updating repo.put/delete, #5661, #5636.
-- docs:
-
-  - add another case of attempted hardlink usage
-  - fix description of borg upgrade hardlink usage, #5518
-  - use HTTPS everywhere
-  - add examples for --paths-from-stdin, --paths-from-command, --paths-separator, #5644
-  - fix typos/grammar
-  - update docs for dev environment installation instructions
-  - recommend running tests only on installed versions for setup
-  - add badge with current status of package
-- vagrant:
-
-  - use brew install --cask ..., #5557
-  - use Python 3.9.1 and PyInstaller 4.1 to build the borg binary
-
-
-Version 1.2.0b1 (2020-12-06)
-----------------------------
-
-Fixes:
-
-- BORG_CACHE_DIR crashing borg if empty, atomic handling of
-  recursive directory creation, #5216
-- fix --dry-run and --stats coexistence, #5415
-- allow EIO with warning when trying to hardlink, #4336
-- export-tar: set tar format to GNU_FORMAT explicitly, #5274
-- use --timestamp for {utcnow} and {now} if given, #5189
-- make timestamp helper timezone-aware
-
-New features:
-
-- create: implement --paths-from-stdin and --paths-from-command, see #5492.
-  These switches read paths to archive from stdin. Delimiter can specified
-  by --paths-delimiter=DELIM. Paths read will be added honoring every
-  option but exclusion options and --one-file-system. borg won't recurse
-  into directories.
-- 'obfuscate' pseudo compressor obfuscates compressed chunk size in repo
-- add pyfuse3 (successor of llfuse) as an alternative lowlevel fuse
-  implementation to llfuse (deprecated), #5407.
-  FUSE implementation can be switched via env var BORG_FUSE_IMPL.
-- allow appending to the files cache filename with BORG_FILES_CACHE_SUFFIX
-- create: implement --stdin-mode, --stdin-user and --stdin-group, #5333
-
-Other changes:
-
-- split recursive directory walking/processing into directory walking and
-  item processing.
-- fix warning by importing setuptools before distutils.
-- debug info: include infos about FUSE implementation, #5546
-- testing:
-
-  - add a test for the hashindex corruption bug, #5531 #4829
-  - move away from travis-ci, use github actions, #5528 #5467
-  - test both on fuse2 and fuse3
-  - upload coverage reports to codecov
-  - fix spurious failure in test_cache_files, #5438
-  - add tests for Location.with_timestamp
-  - tox: add a non-fuse env to the envlist
-- vagrant:
-
-  - use python 3.7.latest and pyinstaller 4.0 for binary creation
-  - pyinstaller: compute basepath from spec file location
-  - vagrant: updates/fixes for archlinux box, #5543
-- docs:
-
-  - "filename with spaces" example added to exclude file, #5236
-  - add a hint about sleeping computer, #5301
-  - how to adjust macOS >= Catalina security settings, #5303
-  - process/policy for adding new compression algorithms
-  - updated docs about hacked backup client, #5480
-  - improve ansible deployment docs, make it more generic
-  - how to approach borg speed issues, give speed example, #5371
-  - fix mathematical inaccuracy about chunk size, #5336
-  - add example for excluding content using --pattern cli option
-  - clarify borg create's '--one-file-system' option, #4009
-  - improve docs/FAQ about append-only remote repos, #5497
-  - fix reST markup issues, labels
-  - add infos about contributor retirement status
-
-
-Version 1.2.0a9 (2020-10-05)
-----------------------------
-
-Fixes:
-
-- fix memory leak related to preloading, #5202
-- check --repair: fix potential data loss, #5325
-- persist shadow_index in between borg runs, #4830
-- fix hardlinked CACHEDIR.TAG processing, #4911
-- --read-special: .part files also should be regular files, #5217
-- allow server side enforcing of umask, --umask is for the local borg
-  process only (see docs), #4947
-- exit with 128 + signal number, #5161
-- borg config --list does not show last_segment_checked, #5159
-- locking:
-
-  - fix ExclusiveLock race condition bug, #4923
-  - fix race condition in lock migration, #4953
-  - fix locking on openindiana, #5271
-
-New features:
-
-- --content-from-command: create archive using stdout of given command, #5174
-- allow key-import + BORG_KEY_FILE to create key files
-- build directory-based binary for macOS to avoid Gatekeeper delays
-
-Other changes:
-
-- upgrade bundled zstd to 1.4.5
-- upgrade bundled xxhash to 0.8.0, #5362
-- if self test fails, also point to OS and hardware, #5334
-- misc. shell completions fixes/updates, rewrite zsh completion
-- prettier error message when archive gets too big, #5307
-- stop relying on `false` exiting with status code 1
-- rephrase some warnings, #5164
-- parseformat: unnecessary calls removed, #5169
-- testing:
-
-  - enable Python3.9 env for test suite and VMs, #5373
-  - drop python 3.5, #5344
-  - misc. vagrant fixes/updates
-  - misc. testing fixes, #5196
-- docs:
-
-  - add ssh-agent pull backup method to doc, #5288
-  - mention double --force in prune docs
-  - update Homebrew install instructions, #5185
-  - better description of how cache and rebuilds of it work
-    and how the workaround applies to that
-  - point to borg create --list item flags in recreate usage, #5165
-  - add a note to create from stdin regarding files cache, #5180
-  - add security faq explaining AES-CTR crypto issues, #5254
-  - clarify --exclude-if-present in recreate, #5193
-  - add socat pull mode, #5150, #900
-  - move content of resources doc page to community project, #2088
-  - explain hash collision, #4884
-  - clarify --recompress option, #5154
-
-
-Version 1.2.0a8 (2020-04-22)
-----------------------------
-
-Fixes:
-
-- fixed potential index corruption / data loss issue due to bug in hashindex_set, #4829.
-  Please read and follow the more detailed notes close to the top of this document.
-- fix crash when upgrading erroneous hints file, #4922
-- commit-time free space calc: ignore bad compact map entries, #4796
-- info: if the archive doesn't exist, print a pretty message, #4793
-- --prefix / -P: fix processing, avoid argparse issue, #4769
-- ignore EACCES (errno 13) when hardlinking, #4730
-- add a try catch when formatting the info string, #4818
-- check: do not stumble over invalid item key, #4845
-- update prevalence of env vars to set config and cache paths
-- mount: fix FUSE low linear read speed on large files, #5032
-- extract: fix confusing output of borg extract --list --strip-components, #4934
-- recreate: support --timestamp option, #4745
-- fix ProgressIndicator msgids (JSON output), #4935
-- fuse: set f_namemax in statfs result, #2684
-- accept absolute paths on windows
-- pyinstaller: work around issue with setuptools > 44
-
-New features:
-
-- chunker speedup (plus regression test)
-- added --consider-checkpoints and related test, #4788
-- added --noflags option, deprecate --nobsdflags option, #4489
-- compact: add --threshold option, #4674
-- mount: add birthtime to FUSE entries
-- support platforms with no os.link, #4901 - if we don't have os.link,
-  we just extract another copy instead of making a hardlink.
-- move sync_file_range to its own extension for better platform compatibility.
-- new --bypass-lock option to bypass locking, e.g. for read-only repos
-- accept absolute paths by removing leading slashes in patterns of all
-  sorts but re: style, #4029
-- delete: new --keep-security-info option
-
-Other changes:
-
-- support msgpack 0.6.2 and 1.0.0, #5065
-- upgrade bundled zstd to 1.4.4
-- upgrade bundled lz4 to 1.9.2
-- upgrade xxhash to 0.7.3
-- require recent enough llfuse for birthtime support, #5064
-- only store compressed data if the result actually is smaller, #4516
-- check: improve error output for matching index size, see #4829
-- ignore --stats when given with --dry-run, but continue, #4373
-- replaced usage of os.statvfs with shutil.disk_usage (better cross-platform support).
-- fuse: remove unneeded version check and compat code, micro opts
-- docs:
-
-  - improve description of path variables
-  - document how to completely delete data, #2929
-  - add FAQ about Borg config dir, #4941
-  - add docs about errors not printed as JSON, #4073
-  - update usage_general.rst.inc
-  - added "Will move with BORG_CONFIG_DIR variable unless specified." to BORG_SECURITY_DIR info.
-  - put BORG_SECURITY_DIR immediately below BORG_CONFIG_DIR (and moved BORG_CACHE_DIR up before them).
-  - add paragraph regarding cache security assumptions, #4900
-  - tell about borg cache security precautions
-  - add FAQ describing difference between a local repo vs. repo on a server.
-  - document how to test exclusion patterns without performing an actual backup
-  - create: tell that "Calculating size" time and space needs are caused by --progress
-  - fix/improve documentation for @api decorator, #4674
-  - add a pull backup / push restore how-to, #1552
-  - fix man pages creation, #4752
-  - more general FAQ for backup and retain original paths, #4532
-  - explain difference between --exclude and --pattern, #4118
-  - add FAQ for preventing SSH timeout in extract, #3866
-  - improve password FAQ (decrease pw length, add -w 0 option to base64 to prevent line wrap), #4591
-  - add note about patterns and stored paths, #4160
-  - add upgrade of tools to pip installation how-to, #5090
-  - document one cause of orphaned chunks in check command, #2295
-  - clean up the whole check usage paragraph
-  - FAQ: linked recommended restrictions to ssh public keys on borg servers, #4946
-  - fixed "doc downplays severity of Nonce reuse issue", #4883
-  - borg repo restore instructions needed, #3428
-  - new FAQ: A repo is corrupt and must be replaced with an older repo.
-  - clarify borg init's encryption modes
-- native windows port:
-
-  - update README_WINDOWS.rst
-  - updated pyinstaller spec file to support windows builds
-- testing / CI:
-
-  - improved travis config / install script, improved macOS builds
-  - allow osx builds to fail, #4955
-  - Windows 10 build on Appveyor CI
-- vagrant:
-
-  - upgrade pyinstaller to v3.5 + patch
-  - use py369 for binary build, add py380 for tests
-  - fix issue in stretch VM hanging at grub installation
-  - add a debian buster and a ubuntu focal VM
-  - update darwin box to 10.12
-  - upgrade FreeBSD box to 12.1
-  - fix debianoid virtualenv packages
-  - use pyenv in freebsd64 VM
-  - remove the flake8 test
-  - darwin: avoid error if pkg is already installed
-  - debianoid: don't interactively ask questions
-
-
-Version 1.2.0a7 (2019-09-07)
-----------------------------
-
-Fixes:
-
-- slave hardlinks extraction issue, see #4350
-- extract: fix KeyError for "partial" extraction, #4607
-- preload chunks for hardlink slaves w/o preloaded master, #4350
-- fix preloading for old remote servers, #4652
-- fix partial extract for hardlinked contentless file types, #4725
-- Repository.open: use stat() to check for repo dir, #4695
-- Repository.check_can_create_repository: use stat() to check, ~ #4695.
-- SecurityManager.known(): check all files, #4614
-- after double-force delete, warn about necessary repair, #4704
-- cope with ANY error when importing pytest into borg.testsuite, #4652
-- fix invalid archive error message
-- setup.py: fix detection of missing Cython
-- filter out selinux xattrs, #4574
-- location arg - should it be optional? #4541
-- enable placeholder usage in --comment, #4559
-- use whitelist approach for borg serve, #4097
-
-New features:
-
-- minimal native Windows support, see windows readme (work in progress)
-- create: first ctrl-c (SIGINT) triggers checkpoint and abort, #4606
-- new BORG_WORKAROUNDS mechanism, basesyncfile, #4710
-- remove WSL autodetection. if WSL still has this problem, you need to
-  set BORG_WORKAROUNDS=basesyncfile in the borg process environment to
-  work around it.
-- support xxh64 checksum in addition to the hashlib hashes in borg list
-- enable placeholder usage in all extra archive arguments
-- enable placeholder usage in --comment, #4559
-- enable placeholder usage in --glob-archives, #4495
-- ability to use a system-provided version of "xxhash"
-- create:
-
-  - changed the default behaviour to not store the atime of fs items. atime is
-    often rather not interesting and fragile - it easily changes even if nothing
-    else has changed and, if stored into the archive, spoils deduplication of
-    the archive metadata stream.
-  - if you give the --noatime option, borg will output a deprecation warning
-    because it is currently ignored / does nothing.
-    Please remove the --noatime option when using borg 1.2.
-  - added a --atime option for storing files' atime into an archive
-
-Other changes:
-
-- argparser: always use REPOSITORY in metavar
-- do not check python/libc for borg serve, #4483
-- small borg compact improvements, #4522
-- compact: log freed space at INFO level
-- tests:
-
-  - tox / travis: add testing on py38-dev
-  - fix broken test that relied on improper zlib assumptions
-  - pure-py msgpack warning shall not make a lot of tests fail, #4558
-  - rename test_mount_hardlinks to test_fuse_mount_hardlinks (master)
-  - vagrant: add up-to-date openindiana box (py35, openssl10)
-  - get rid of confusing coverage warning, #2069
-- docs:
-
-  - reiterate that 'file cache names are absolute' in FAQ,
-    mention bind mount solution, #4738
-  - add restore docs, #4670
-  - updated docs to cover use of temp directory on remote, #4545
-  - add a push-style example to borg-create(1), #4613
-  - timestamps in the files cache are now usually ctime, #4583
-  - benchmark crud: clarify that space is used until compact
-  - update documentation of borg create,
-    corrects a mention of borg 1.1 as a future version.
-  - fix osxfuse github link in installation docs
-  - how to supply a passphrase, use crypto devices, #4549
-  - extract: document limitation "needs empty destination",  #4598
-  - update macOS Brew link
-  - add note about software for automating backup
-  - compact: improve docs,
-  - README: new URL for funding options
-
-
-Version 1.2.0a6 (2019-04-22)
-----------------------------
-
-Fixes:
-
-- delete / prune: consider part files correctly for stats, #4507
-- fix "all archives" stats considering part files, #4329
-- create: only run stat_simple_attrs() once
-- create: --stats does not work with --dry-run, exit with error msg, #4373
-- give "invalid repo" error msg if repo config not found, #4411
-
-New features:
-
-- display msgpack version as part of sysinfo (e.g. in tracebacks)
-
-Other changes:
-
-- docs:
-
-  - sdd "SSH Configuration" section, #4493, #3988, #636, #4485
-  - better document borg check --max-duration, #4473
-  - sorted commands help in multiple steps, #4471
-- testing:
-
-  - travis: use py 3.5.3 and 3.6.7 on macOS to get a pyenv-based python
-    build with openssl 1.1
-  - vagrant: use py 3.5.3 and 3.6.8 on darwin64 VM to build python and
-    borg with openssl 1.1
-  - pytest: -v and default XDISTN to 1, #4481
-
-
-Version 1.2.0a5 (2019-03-21)
-----------------------------
-
-Fixes:
-
-- warn if a file has changed while being backed up, #1750
-- lrucache: regularly remove old FDs, #4427
-- borg command shall terminate with rc 2 for ImportErrors, #4424
-- make freebsd xattr platform code api compatible with linux, #3952
-
-Other changes:
-
-- major setup code refactoring (especially how libraries like openssl, liblz4,
-  libzstd, libb2 are discovered and how it falls back to code bundled with
-  borg), new: uses pkg-config now (and needs python "pkgconfig" package
-  installed), #1925
-
-  if you are a borg package maintainer, please try packaging this
-  (see comments in setup.py).
-- Vagrantfile: add zstd, reorder, build env vars, #4444
-- travis: install script improvements
-- update shell completions
-- docs:
-
-  - add a sample logging.conf in docs/misc, #4380
-  - fix spelling errors
-  - update requirements / install docs, #4374
-
-
-Version 1.2.0a4 (2019-03-11)
-----------------------------
-
-Fixes:
-
-- do not use O_NONBLOCK for special files, like FIFOs, block and char devices
-  when using --read-special. fixes backing up FIFOs. fixes to test. #4394
-- more LibreSSL build fixes: LibreSSL has HMAC_CTX_free and HMAC_CTX_new
-
-New features:
-
-- check: incremental repo check (only checks crc32 for segment entries), #1657
-  borg check --repository-only --max-duration SECONDS ...
-- delete: timestamp for borg delete --info added, #4359
-
-Other changes:
-
-- redo stale lock handling, #3986
-  drop BORG_HOSTNAME_IS_UNIQUE (please use BORG_HOST_ID if needed).
-  borg now always assumes it has a unique host id - either automatically
-  from fqdn plus uuid.getnode() or overridden via BORG_HOST_ID.
-- docs:
-
-  - added Alpine Linux to distribution list
-  - elaborate on append-only mode docs
-- vagrant:
-
-  - darwin: new 10.12 box
-  - freebsd: new 12.0 box
-  - openbsd: new 6.4 box
-  - misc. updates / fixes
-
-
-Version 1.2.0a3 (2019-02-26)
-----------------------------
-
-Fixes:
-
-- LibreSSL build fixes, #4403
-- dummy ACL/xattr code fixes (used by OpenBSD and others), #4403
-- create: fix openat/statat issues for root directory, #4405
-
-
-Version 1.2.0a2 and earlier (2019-02-24)
-----------------------------------------
-
-New features:
-
-- compact: "borg compact" needs to be used to free repository space by
-  compacting the segments (reading sparse segments, rewriting still needed
-  data to new segments, deleting the sparse segments).
-  Borg < 1.2 invoked compaction automatically at the end of each repository
-  writing command.
-  Borg >= 1.2 does not do that any more to give better speed, more control,
-  more segment file stability (== less stuff moving to newer segments) and
-  more robustness.
-  See the docs about "borg compact" for more details.
-- "borg compact --cleanup-commits" is to cleanup the tons of 17byte long
-  commit-only segment files caused by borg 1.1.x issue #2850.
-  Invoke this once after upgrading (the server side) borg to 1.2.
-  Compaction now automatically removes unneeded commit-only segment files.
-- prune: Show which rule was applied to keep archive, #2886
-- add fixed blocksize chunker (see --chunker-params docs), #1086
-
-Fixes:
-
-- avoid stale filehandle issues, #3265
-- use more FDs, avoid race conditions on active fs, #906, #908, #1038
-- add O_NOFOLLOW to base flags, #908
-- compact:
-
-  - require >10% freeable space in a segment, #2985
-  - repository compaction now automatically removes unneeded 17byte
-    commit-only segments, #2850
-- make swidth available on all posix platforms, #2667
-
-Other changes:
-
-- repository: better speed and less stuff moving around by using separate
-  segment files for manifest DELETEs and PUTs, #3947
-- use pyinstaller v3.3.1 to build binaries
-- update bundled zstd code to 1.3.8, #4210
-- update bundled lz4 code to 1.8.3, #4209
-- msgpack:
-
-  - switch to recent "msgpack" pypi pkg name, #3890
-  - wrap msgpack to avoid future compat complications, #3632, #2738
-  - support msgpack 0.6.0 and 0.6.1, #4220, #4308
-
-- llfuse: modernize / simplify llfuse version requirements
-- code refactorings / internal improvements:
-
-  - include size/csize/nfiles[_parts] stats into archive, #3241
-  - calc_stats: use archive stats metadata, if available
-  - crypto: refactored crypto to use an AEAD style API
-  - crypto: new AES-OCB, CHACHA20-POLY1305
-  - create: use less syscalls by not using a python file obj, #906, #3962
-  - diff: refactor the diff functionality to new ItemDiff class, #2475
-  - archive: create FilesystemObjectProcessors class
-  - helpers: make a package, split into smaller modules
-  - xattrs: move to platform package, use cython instead ctypes, #2495
-  - xattrs/acls/bsdflags: misc. code/api optimizations
-  - FUSE: separate creation of filesystem from implementation of llfuse funcs, #3042
-  - FUSE: use unpacker.tell() instead of deprecated write_bytes, #3899
-  - setup.py: move build_man / build_usage code to setup_docs.py
-  - setup.py: update to use a newer Cython/setuptools API for compiling .pyx -> .c, #3788
-  - use python 3.5's os.scandir / os.set_blocking
-  - multithreading preparations (not used yet):
-
-    - item.to_optr(), Item.from_optr()
-    - fix chunker holding the GIL during blocking I/O
-  - C code portability / basic MSC compatibility, #4147, #2677
-- testing:
-
-  - vagrant: new VMs for linux/bsd/darwin, most with OpenSSL 1.1 and py36
-
-
-Version 1.1.18 (2022-06-05)
----------------------------
-
-Compatibility notes:
-
-- When upgrading from borg 1.0.x to 1.1.x, please note:
-
-  - read all the compatibility notes for 1.1.0*, starting from 1.1.0b1.
-  - borg upgrade: you do not need to and you also should not run it.
-  - borg might ask some security-related questions once after upgrading.
-    You can answer them either manually or via environment variable.
-    One known case is if you use unencrypted repositories, then it will ask
-    about a unknown unencrypted repository one time.
-  - your first backup with 1.1.x might be significantly slower (it might
-    completely read, chunk, hash a lot files) - this is due to the
-    --files-cache mode change (and happens every time you change mode).
-    You can avoid the one-time slowdown by using the pre-1.1.0rc4-compatible
-    mode (but that is less safe for detecting changed files than the default).
-    See the --files-cache docs for details.
-- 1.1.11 removes WSL autodetection (Windows 10 Subsystem for Linux).
-  If WSL still has a problem with sync_file_range, you need to set
-  BORG_WORKAROUNDS=basesyncfile in the borg process environment to
-  work around the WSL issue.
-- 1.1.14 changes return codes due to a bug fix:
-  In case you have scripts expecting rc == 2 for a signal exit, you need to
-  update them to check for >= 128 (as documented since long).
-- 1.1.15 drops python 3.4 support, minimum requirement is 3.5 now.
-- 1.1.17 install_requires the "packaging" pypi package now.
-
-New features:
-
-- check --repair: significantly speed up search for next valid object in segment, #6022
-- create: add retry_erofs workaround for O_NOATIME issue on volume shadow copies in WSL1, #6024
-- key export: display key if path is '-' or not given, #6092
-- list --format: add command_line to format keys, #6108
-
-Fixes:
-
-- check: improve error handling for corrupt archive metadata block,
-  make robust_iterator more robust, #4777
-- diff: support presence change for blkdev, chrdev and fifo items, #6483
-- diff: reduce memory consumption, fix is_hardlink_master
-- init: disallow overwriting of existing keyfiles
-- info: fix authenticated mode repo to show "Encrypted: No", #6462
-- info: emit repo info even if repo has 0 archives, #6120
-- list: remove placeholders for shake_* hashes, #6082
-- mount -o versions: give clear error msg instead of crashing
-- show_progress: add finished=true/false to archive_progress json, #6570
-- fix hardlinkable file type check, #6037
-- do not show archive name in error msgs referring to the repository, #6023
-- prettier error msg (no stacktrace) if exclude file is missing, #5734
-- do not require BORG_CONFIG_DIR if BORG_{SECURITY,KEYS}_DIR are set, #5979
-- atomically create the CACHE_TAG file, #6028
-- deal with the SaveFile/SyncFile race, docs, see #6176 5c5b59bc9
-- avoid expanding path into LHS of formatting operation + tests, #6064 #6063
-- repository: quota / compactable computation fixes, #6119.
-  This is mainly to keep the repo code in sync with borg 1.2. As borg 1.1
-  compacts immediately, there was not really an issue with this in 1.1.
-- fix transaction rollback: use files cache filename as found in txn.active, #6353
-- do not load files cache for commands not using it, fixes #5673
-- fix scp repo url parsing for ip v6 addrs, #6526
-- repo::archive location placeholder expansion fixes, #5826, #5998
-
-  - use expanded location for log output
-  - support placeholder expansion for BORG_REPO env var
-- respect umask for created directory and file modes, #6400
-- safer truncate_and_unlink implementation
-
-Other changes:
-
-- upgrade bundled xxhash code to 0.8.1
-- fix xxh64 related build (setup.py and post-0.8.1 patch for static_assert).
-  The patch was required to build the bundled xxhash code on FreeBSD, see
-  https://github.com/Cyan4973/xxHash/pull/670
-- msgpack build: remove endianness macro, #6105
-- update and fix shell completions
-- fuse: remove unneeded version check and compat code
-- delete --force: do not ask when deleting a repo, #5941
-- delete: don't commit if nothing was deleted, avoid cache sync, #6060
-- delete: add repository id and location to prompt
-- compact segments: improve freeable / freed space log output, #5679
-- if ensure_dir() fails, give more informative error message, #5952
-- load_key: no key is same as empty key, #6441
-- better error msg for defect or unsupported repo configs, #6566
-- use hmac.compare_digest instead of ==, #6470
-- implement more standard hashindex.setdefault behaviour
-- remove stray punctuation from secure-erase message
-- add development.lock.txt, use a real python 3.5 to generate frozen reqs
-- setuptools 60.7.0 breaks pyinstaller, #6246
-- setup.py clean2 was added to work around some setuptools customizability limitation.
-- allow extra compiler flags for every extension build
-- C code: make switch fallthrough explicit
-- Cython code: fix "useless trailing comma" cython warnings
-- requirements.lock.txt: use the latest cython 0.29.30
-- fix compilation warnings: ‘PyUnicode_AsUnicode’ is deprecated
-- docs:
-
-  - ~/.config/borg/keys is not used for repokey keys, #6107
-  - excluded parent dir's metadata can't restore, #6062
-  - permissions note rewritten to make it less confusing, #5490
-  - add note about grandfather-father-son backup retention policy / rotation scheme
-  - clarify who starts the remote agent (borg serve)
-  - test/improve pull backup docs, #5903
-  - document the socat pull mode described in #900 #515ß
-  - borg serve: improve ssh forced commands docs, #6083
-  - improve docs for borg list --format, #6080
-  - fix the broken link to .nix file
-  - clarify pattern usage with commands, #5176
-  - clarify user_id vs uid for fuse, #5723
-  - fix binary build freebsd/macOS version, #5942
-  - FAQ: fix manifest-timestamp path, #6016
-  - remove duplicate faq entries, #5926
-  - fix sphinx warnings, #5919
-  - virtualisation speed tips
-  - fix values of TAG bytes, #6515
-  - recommend umask for passphrase file perms
-  - update link to ubuntu packages, #6485
-  - clarify on-disk order and size of log entry fields, #6357
-  - do not transform --/--- to unicode dashes
-  - improve linking inside docs, link to borg_placeholders, link to borg_patterns
-  - use same phrasing in misc. help texts
-  - borg init: explain the encryption modes better
-  - explain the difference between a path that ends with or without a slash, #6297
-  - clarify usage of patternfile roots, #6242
-  - borg key export: add examples
-  - updates about features not experimental any more: FUSE "versions" view, --pattern*, #6134
-  - fix/update cygwin package requirements
-  - impact of deleting path/to/repo/nonce, #5858
-  - warn about tampered server nonce
-  - mention BORG_FILES_CACHE_SUFFIX as alternative to BORG_FILES_CACHE_TTL, #5602
-  - add a troubleshooting note about "is not a valid repository" to the FAQ
-- vagrant / CI / testing:
-
-  - misc. fixes and updates, new python versions
-  - macOS on github: re-enable fuse2 testing by downgrading to older macOS, #6099
-  - fix OpenBSD symlink mode test failure, #2055
-  - use the generic/openbsd6 box
-  - strengthen the test: we can read data w/o nonces
-  - add tests for path/to/repo/nonce deletion
-  - darwin64: backport some tunings from master
-  - darwin64: remove fakeroot, #6314
-  - darwin64: fix vagrant scp, #5921
-  - darwin64: use macfuse instead of osxfuse
-  - add ubuntu "jammy" 22.04 LTS VM
-  - adapt memory for openindiana64 and darwin64
-
-
-Version 1.1.17 (2021-07-12)
----------------------------
-
-Compatibility notes:
-
-- When upgrading from borg 1.0.x to 1.1.x, please note:
-
-  - read all the compatibility notes for 1.1.0*, starting from 1.1.0b1.
-  - borg upgrade: you do not need to and you also should not run it.
-  - borg might ask some security-related questions once after upgrading.
-    You can answer them either manually or via environment variable.
-    One known case is if you use unencrypted repositories, then it will ask
-    about a unknown unencrypted repository one time.
-  - your first backup with 1.1.x might be significantly slower (it might
-    completely read, chunk, hash a lot files) - this is due to the
-    --files-cache mode change (and happens every time you change mode).
-    You can avoid the one-time slowdown by using the pre-1.1.0rc4-compatible
-    mode (but that is less safe for detecting changed files than the default).
-    See the --files-cache docs for details.
-- 1.1.11 removes WSL autodetection (Windows 10 Subsystem for Linux).
-  If WSL still has a problem with sync_file_range, you need to set
-  BORG_WORKAROUNDS=basesyncfile in the borg process environment to
-  work around the WSL issue.
-- 1.1.14 changes return codes due to a bug fix:
-  In case you have scripts expecting rc == 2 for a signal exit, you need to
-  update them to check for >= 128 (as documented since long).
-- 1.1.15 drops python 3.4 support, minimum requirement is 3.5 now.
-- 1.1.17 install_requires the "packaging" pypi package now.
-
-Fixes:
-
-- pyinstaller dir-mode: fix pyi detection / LIBPATH treatment, #5897
-- handle crash due to kill stale lock race, #5828
-- fix BORG_CACHE_DIR crashing borg if empty, #5216
-- create --dry-run: fix display of kept tagfile, #5834
-- fix missing parameter in "did not consistently fail" msg, #5822
-- missing / healed chunks: always tell chunk ID, #5704
-- benchmark: make sure cleanup happens even on exceptions, #5630
-
-New features:
-
-- implement BORG_SELFTEST env variable, #5871.
-  this can be used to accelerate borg startup a bit. not recommended for
-  normal usage, but borg mass hosters with a lot of borg invocations can
-  save some resources with this. on my laptop, this saved ~100ms cpu time
-  (sys+user) per borg command invocation.
-- implement BORG_LIBC env variable to give the libc filename, #5870.
-  you can use this if a borg does not find your libc.
-- check: add progress indicator for archive check.
-- allow --files-cache=size (not recommended, make sure you know what you do)
-
-Other changes:
-
-- Python 3.10 now officially supported!
-  we test on py310-dev on github CI since a while and now also on the vagrant
-  machines, so it should work ok.
-- github CI: test on py310 (again)
-- get rid of distutils, use packaging and setuptools.
-  distutils is deprecated and gives warnings on py 3.10.
-- setup.py: rename "clean" to "clean2" to avoid shadowing the "clean" command.
-- remove libc filename fallback for the BSDs (there is no "usual" name)
-- cleanup flake8 checks, fix some pep8 violations.
-- docs building: replace deprecated function ".add_stylesheet()" for Sphinx 4 compatibility
-- docs:
-
-  - add a hint on sleeping computer and ssh connections, #5301
-  - update the documentation on hacked backup client, #5480
-  - improve docs/FAQ about append-only remote repos, #5497
-  - complement the documentation for pattern files and exclude files, #5520
-  - "filename with spaces" example added to exclude file, #5236
-    note: no whitespace escaping needed, processed by borg.
-  - add info on renaming repositories, #5240
-  - clarify borg check --verify-data, #5808
-  - add notice about defective hardware to check documentation, #5753
-  - add paragraph added in #5855 to utility documentation source
-  - add missing leading slashes in help patterns, #5857
-  - clarify "you will need key and passphrase" borg init warning, #4622
-  - pull mode: add some warnings, #5827
-  - mention tar --compare (compare archive to fs files), #5880
-  - fix typos, backport of #5597
-- vagrant:
-
-  - add py3.7.11 for binary build, also add 3.10-dev.
-  - use latest Cython 0.29.23 for py310 compat fixes.
-  - more RAM for openindiana upgrade plan resolver, it just hangs (swaps?) if
-    there is too little RAM.
-  - fix install_pyenv to adapt to recent changes in pyenv (same as in master now).
-  - use generic/netbsd9 box, copied from master branch.
-
-
-Version 1.1.16 (2021-03-23)
----------------------------
-
-Fixes:
-
-- setup.py: add special openssl prefix for Apple M1 compatibility
-- do not recurse into duplicate roots, #5603
-- remove empty shadowed_segments lists, #5275, #5614
-- fix libpython load error when borg fat binary / dir-based binary is invoked
-  via a symlink by upgrading pyinstaller to v4.2, #5688
-- config: accept non-int value (like 500M or 100G) for max_segment_size or
-  storage_quota, #5639.
-  please note: when setting a non-int value for this in a repo config,
-  using the repo will require borg >= 1.1.16.
-
-New features:
-
-- bundled msgpack: drop support for old buffer protocol to support Python 3.10
-- verbose files cache logging via --debug-topic=files_cache, #5659.
-  Use this if you suspect that borg does not detect unmodified files as expected.
-- create/extract: add --noxattrs and --noacls option, #3955.
-  when given with borg create, borg will not get xattrs / ACLs from input files
-  (and thus, it will not archive xattrs / ACLs). when given with borg extract,
-  borg will not read xattrs / ACLs from archive and will not set xattrs / ACLs
-  on extracted files.
-- diff: add --json-lines option, #3765
-- check: debug log segment filename
-- borg debug dump-hints
-
-Other changes:
-
-- Tab completion support for additional archives for 'borg delete'
-- repository: deduplicate code of put and delete, no functional change
-- tests: fix result order issue (sporadic test failure on openindiana)
-- vagrant:
-
-  - upgrade pyinstaller to v4.2, #5671
-  - avoid grub-install asking interactively for device
-  - remove the xenial box
-  - update freebsd box to 12.1
-- docs:
-
-  - update macOS install instructions, #5677
-  - use macFUSE (not osxfuse) for Apple M1 compatibility
-  - update docs for dev environment installation instructions, #5643
-  - fix grammar in faq
-  - recommend running tests only on installed versions for setup
-  - add link back to git-installation
-  - remove /var/cache exclusion in example commands, #5625.
-    This is generally a poor idea and shouldn't be promoted through examples.
-  - add repology.org badge with current packaging status
-  - explain hash collision
-  - add unsafe workaround to use an old repo copy, #5722
-
-
-Version 1.1.15 (2020-12-25)
----------------------------
-
-Fixes:
-
-- extract:
-
-  - improve exception handling when setting xattrs, #5092.
-  - emit a warning message giving the path, xattr key and error message.
-  - continue trying to restore other xattrs and bsdflags of the same file
-    after an exception with xattr-setting happened.
-- export-tar:
-
-  - set tar format to GNU_FORMAT explicitly, #5274
-  - fix memory leak with ssh: remote repository, #5568
-  - fix potential memory leak with ssh: remote repository with partial extraction
-- create: fix --dry-run and --stats coexistence, #5415
-- use --timestamp for {utcnow} and {now} if given, #5189
-
-New features:
-
-- create: implement --stdin-mode, --stdin-user and --stdin-group, #5333
-- allow appending the files cache filename with BORG_FILES_CACHE_SUFFIX env var
-
-Other changes:
-
-- drop python 3.4 support, minimum requirement is 3.5 now.
-- enable using libxxhash instead of bundled xxh64 code
-- update llfuse requirements (1.3.8)
-- set cython language_level in some files to fix warnings
-- allow EIO with warning when trying to hardlink
-- PropDict: fail early if internal_dict is not a dict
-- update shell completions
-- tests / CI
-
-  - add a test for the hashindex corruption bug, #5531 #4829
-  - fix spurious failure in test_cache_files, #5438
-  - added a github ci workflow
-  - reduce testing on travis, no macOS, no py3x-dev, #5467
-  - travis: use newer dists, native py on dist
-- vagrant:
-
-  - remove jessie and trusty boxes, #5348 #5383
-  - pyinstaller 4.0, build on py379
-  - binary build on stretch64, #5348
-  - remove easy_install based pip installation
-- docs:
-
-  - clarify '--one-file-system' for btrfs, #5391
-  - add example for excluding content using the --pattern cmd line arg
-  - complement the documentation for pattern files and exclude files, #5524
-  - made ansible playbook more generic, use package instead of pacman. also
-    change state from "latest" to "present".
-  - complete documentation on append-only remote repos, #5497
-  - internals: rather talk about target size than statistics, #5336
-  - new compression algorithm policy, #1633 #5505
-  - faq: add a hint on sleeping computer, #5301
-  - note requirements for full disk access on macOS Catalina, #5303
-  - fix/improve description of borg upgrade hardlink usage, #5518
-- modernize 1.1 code:
-
-  - drop code/workarounds only needed to support Python 3.4
-  - remove workaround for pre-release py37 argparse bug
-  - removed some outdated comments/docstrings
-  - requirements: remove some restrictions, lock on current versions
-
-
-Version 1.1.14 (2020-10-07)
----------------------------
-
-Fixes:
-
-- check --repair: fix potential data loss when interrupting it, #5325
-- exit with 128 + signal number (as documented) when borg is killed by a signal, #5161
-- fix hardlinked CACHEDIR.TAG processing, #4911
-- create --read-special: .part files also should be regular files, #5217
-- llfuse dependency: choose least broken 1.3.6/1.3.7.
-  1.3.6 is broken on python 3.9, 1.3.7 is broken on FreeBSD.
-
-Other changes:
-
-- upgrade bundled xxhash to 0.7.4
-- self test: if it fails, also point to OS and hardware, #5334
-- pyinstaller: compute basepath from spec file location
-- prettier error message when archive gets too big, #5307
-- check/recreate are not "experimental" any more (but still potentially dangerous):
-
-  - recreate: remove extra confirmation
-  - rephrase some warnings, update docs, #5164
-- shell completions:
-
-  - misc. updates / fixes
-  - support repositories in fish tab completion, #5256
-  - complete $BORG_RECREATE_I_KNOW_WHAT_I_AM_DOING
-  - rewrite zsh completion:
-
-    - completion for almost all optional and positional arguments
-    - completion for Borg environment variables (parameters)
-- use "allow/deny list" instead of "white/black list" wording
-- declare "allow_cache_wipe" marker in setup.cfg to avoid pytest warning
-- vagrant / tests:
-
-  - misc. fixes / updates
-  - use python 3.5.10 for binary build
-  - build directory-based binaries additionally to the single file binaries
-  - add libffi-dev, required to build python
-  - use cryptography<3.0, more recent versions break the jessie box
-  - test on python 3.9
-  - do brew update with /dev/null redirect to avoid "too much log output" on travis-ci
-- docs:
-
-  - add ssh-agent pull backup method docs, #5288
-  - how to approach borg speed issues, #5371
-  - mention double --force in prune docs
-  - update Homebrew install instructions, #5185
-  - better description of how cache and rebuilds of it work
-  - point to borg create --list item flags in recreate usage, #5165
-  - add security faq explaining AES-CTR crypto issues, #5254
-  - add a note to create from stdin regarding files cache, #5180
-  - fix borg.1 manpage generation regression, #5211
-  - clarify how exclude options work in recreate, #5193
-  - add section for retired contributors
-  - hint about not misusing private email addresses of contributors for borg support
-
-
-Version 1.1.13 (2020-06-06)
----------------------------
-
-Compatibility notes:
-
-- When upgrading from borg 1.0.x to 1.1.x, please note:
-
-  - read all the compatibility notes for 1.1.0*, starting from 1.1.0b1.
-  - borg upgrade: you do not need to and you also should not run it.
-  - borg might ask some security-related questions once after upgrading.
-    You can answer them either manually or via environment variable.
-    One known case is if you use unencrypted repositories, then it will ask
-    about a unknown unencrypted repository one time.
-  - your first backup with 1.1.x might be significantly slower (it might
-    completely read, chunk, hash a lot files) - this is due to the
-    --files-cache mode change (and happens every time you change mode).
-    You can avoid the one-time slowdown by using the pre-1.1.0rc4-compatible
-    mode (but that is less safe for detecting changed files than the default).
-    See the --files-cache docs for details.
-- 1.1.11 removes WSL autodetection (Windows 10 Subsystem for Linux).
-  If WSL still has a problem with sync_file_range, you need to set
-  BORG_WORKAROUNDS=basesyncfile in the borg process environment to
-  work around the WSL issue.
-
-Fixes:
-
-- rebuilt using a current Cython version, compatible with python 3.8, #5214
-
-
-Version 1.1.12 (2020-06-06)
----------------------------
-
-Fixes:
-
-- fix preload-related memory leak, #5202.
-- mount / borgfs (FUSE filesystem):
-
-  - fix FUSE low linear read speed on large files, #5067
-  - fix crash on old llfuse without birthtime attrs, #5064 - accidentally
-    we required llfuse >= 1.3. Now also old llfuse works again.
-  - set f_namemax in statfs result, #2684
-- update precedence of env vars to set config and cache paths, #4894
-- correctly calculate compression ratio, taking header size into account, too
-
-New features:
-
-- --bypass-lock option to bypass locking with read-only repositories
-
-Other changes:
-
-- upgrade bundled zstd to 1.4.5
-- travis: adding comments and explanations to Travis config / install script,
-  improve macOS builds.
-- tests: test_delete_force: avoid sporadic test setup issues, #5196
-- misc. vagrant fixes
-- the binary for macOS is now built on macOS 10.12
-- the binaries for Linux are now built on Debian 8 "Jessie", #3761
-- docs:
-
-  - PlaceholderError not printed as JSON, #4073
-  - "How important is Borg config?", #4941
-  - make Sphinx warnings break docs build, #4587
-  - some markup / warning fixes
-  - add "updating borgbackup.org/releases" to release checklist, #4999
-  - add "rendering docs" to release checklist, #5000
-  - clarify borg init's encryption modes
-  - add note about patterns and stored paths, #4160
-  - add upgrade of tools to pip installation how-to
-  - document one cause of orphaned chunks in check command, #2295
-  - linked recommended restrictions to ssh public keys on borg servers in faq, #4946
-
-
-Version 1.1.11 (2020-03-08)
----------------------------
-
-Compatibility notes:
-
-- When upgrading from borg 1.0.x to 1.1.x, please note:
-
-  - read all the compatibility notes for 1.1.0*, starting from 1.1.0b1.
-  - borg upgrade: you do not need to and you also should not run it.
-  - borg might ask some security-related questions once after upgrading.
-    You can answer them either manually or via environment variable.
-    One known case is if you use unencrypted repositories, then it will ask
-    about a unknown unencrypted repository one time.
-  - your first backup with 1.1.x might be significantly slower (it might
-    completely read, chunk, hash a lot files) - this is due to the
-    --files-cache mode change (and happens every time you change mode).
-    You can avoid the one-time slowdown by using the pre-1.1.0rc4-compatible
-    mode (but that is less safe for detecting changed files than the default).
-    See the --files-cache docs for details.
-- 1.1.11 removes WSL autodetection (Windows 10 Subsystem for Linux).
-  If WSL still has a problem with sync_file_range, you need to set
-  BORG_WORKAROUNDS=basesyncfile in the borg process environment to
-  work around the WSL issue.
-
-Fixes:
-
-- fixed potential index corruption / data loss issue due to bug in hashindex_set, #4829.
-  Please read and follow the more detailed notes close to the top of this document.
-- upgrade bundled xxhash to 0.7.3, #4891.
-  0.7.2 is the minimum requirement for correct operations on ARMv6 in non-fixup
-  mode, where unaligned memory accesses cause bus errors.
-  0.7.3 adds some speedups and libxxhash 0.7.3 even has a pkg-config file now.
-- upgrade bundled lz4 to 1.9.2
-- upgrade bundled zstd to 1.4.4
-- fix crash when upgrading erroneous hints file, #4922
-- extract:
-
-  - fix KeyError for "partial" extraction, #4607
-  - fix "partial" extract for hardlinked contentless file types, #4725
-  - fix preloading for old (0.xx) remote servers, #4652
-  - fix confusing output of borg extract --list --strip-components, #4934
-- delete: after double-force delete, warn about necessary repair, #4704
-- create: give invalid repo error msg if repo config not found, #4411
-- mount: fix FUSE mount missing st_birthtime, #4763 #4767
-- check: do not stumble over invalid item key, #4845
-- info: if the archive doesn't exist, print a pretty message, #4793
-- SecurityManager.known(): check all files, #4614
-- Repository.open: use stat() to check for repo dir, #4695
-- Repository.check_can_create_repository: use stat() to check, #4695
-- fix invalid archive error message
-- fix optional/non-optional location arg, #4541
-- commit-time free space calc: ignore bad compact map entries, #4796
-- ignore EACCES (errno 13) when hardlinking the old config, #4730
-- --prefix / -P: fix processing, avoid argparse issue, #4769
-
-New features:
-
-- enable placeholder usage in all extra archive arguments
-- new BORG_WORKAROUNDS mechanism, basesyncfile, #4710
-- recreate: support --timestamp option, #4745
-- support platforms without os.link (e.g. Android with Termux), #4901.
-  if we don't have os.link, we just extract another copy instead of making a hardlink.
-- support linux platforms without sync_file_range (e.g. Android 7 with Termux), #4905
-
-Other:
-
-- ignore --stats when given with --dry-run, but continue, #4373
-- add some ProgressIndicator msgids to code / fix docs, #4935
-- elaborate on "Calculating size" message
-- argparser: always use REPOSITORY in metavar, also use more consistent help phrasing.
-- check: improve error output for matching index size, see #4829
-- docs:
-
-  - changelog: add advisory about hashindex_set bug #4829
-  - better describe BORG_SECURITY_DIR, BORG_CACHE_DIR, #4919
-  - infos about cache security assumptions, #4900
-  - add FAQ describing difference between a local repo vs. repo on a server.
-  - document how to test exclusion patterns without performing an actual backup
-  - timestamps in the files cache are now usually ctime, #4583
-  - fix bad reference to borg compact (does not exist in 1.1), #4660
-  - create: borg 1.1 is not future any more
-  - extract: document limitation "needs empty destination", #4598
-  - how to supply a passphrase, use crypto devices, #4549
-  - fix osxfuse github link in installation docs
-  - add example of exclude-norecurse rule in help patterns
-  - update macOS Brew link
-  - add note about software for automating backups, #4581
-  - AUTHORS: mention copyright+license for bundled msgpack
-  - fix various code blocks in the docs, #4708
-  - updated docs to cover use of temp directory on remote, #4545
-  - add restore docs, #4670
-  - add a pull backup / push restore how-to, #1552
-  - add FAQ how to retain original paths, #4532
-  - explain difference between --exclude and --pattern, #4118
-  - add FAQs for SSH connection issues, #3866
-  - improve password FAQ, #4591
-  - reiterate that 'file cache names are absolute' in FAQ
-- tests:
-
-  - cope with ANY error when importing pytest into borg.testsuite, #4652
-  - fix broken test that relied on improper zlib assumptions
-  - test_fuse: filter out selinux xattrs, #4574
-- travis / vagrant:
-
-  - misc python versions removed / changed (due to openssl 1.1 compatibility)
-    or added (3.7 and 3.8, for better borg compatibility testing)
-  - binary building is on python 3.5.9 now
-- vagrant:
-
-  - add new boxes: ubuntu 18.04 and 20.04, debian 10
-  - update boxes: openindiana, darwin, netbsd
-  - remove old boxes: centos 6
-  - darwin: updated osxfuse to 3.10.4
-  - use debian/ubuntu pip/virtualenv packages
-  - rather use python 3.6.2 than 3.6.0, fixes coverage/sqlite3 issue
-  - use requirements.d/development.lock.txt to avoid compat issues
-- travis:
-
-  - darwin: backport some install code / order from master
-  - remove deprecated keyword "sudo" from travis config
-  - allow osx builds to fail, #4955
-    this is due to travis-ci frequently being so slow that the OS X builds
-    just fail because they exceed 50 minutes and get killed by travis.
-
-
-Version 1.1.10 (2019-05-16)
----------------------------
-
-Fixes:
-
-- extract: hang on partial extraction with ssh: repo, when hardlink master
-  is not matched/extracted and borg hangs on related slave hardlink, #4350
-- lrucache: regularly remove old FDs, #4427
-- avoid stale filehandle issues, #3265
-- freebsd: make xattr platform code api compatible with linux, #3952
-- use whitelist approach for borg serve, #4097
-- borg command shall terminate with rc 2 for ImportErrors, #4424
-- create: only run stat_simple_attrs() once, this increases
-  backup with lots of unchanged files performance by ~ 5%.
-- prune: fix incorrect borg prune --stats output with --dry-run, #4373
-- key export: emit user-friendly error if repo key is exported to a directory,
-  #4348
-
-New features:
-
-- bundle latest supported msgpack-python release (0.5.6), remove msgpack-python
-  from setup.py install_requires - by default we use the bundled code now.
-  optionally, we still support using an external msgpack (see hints in
-  setup.py), but this requires solid requirements management within
-  distributions and is not recommended.
-  borgbackup will break if you upgrade msgpack to an unsupported version.
-- display msgpack version as part of sysinfo (e.g. in tracebacks)
-- timestamp for borg delete --info added, #4359
-- enable placeholder usage in --comment and --glob-archives, #4559, #4495
-
-Other:
-
-- serve: do not check python/libc for borg serve, #4483
-- shell completions: borg diff second archive
-- release scripts: signing binaries with Qubes OS support
-- testing:
-
-  - vagrant: upgrade openbsd box to 6.4
-  - travis-ci: lock test env to py 3.4 compatible versions, #4343
-  - get rid of confusing coverage warning, #2069
-  - rename test_mount_hardlinks to test_fuse_mount_hardlinks,
-    so both can be excluded by "not test_fuse".
-  - pure-py msgpack warning shall not make a lot of tests fail, #4558
-- docs:
-
-  - add "SSH Configuration" section to "borg serve", #3988, #636, #4485
-  - README: new URL for funding options
-  - add a sample logging.conf in docs/misc, #4380
-  - elaborate on append-only mode docs, #3504
-  - installation: added Alpine Linux to distribution list, #4415
-  - usage.html: only modify window.location when redirecting, #4133
-  - add msgpack license to docs/3rd_party/msgpack
-- vagrant / binary builds:
-
-  - use python 3.5.7 for builds
-  - use osxfuse 3.8.3
-
-
-Version 1.1.9 (2019-02-10)
---------------------------
-
-Compatibility notes:
-
-- When upgrading from borg 1.0.x to 1.1.x, please note:
-
-  - read all the compatibility notes for 1.1.0*, starting from 1.1.0b1.
-  - borg upgrade: you do not need to and you also should not run it.
-  - borg might ask some security-related questions once after upgrading.
-    You can answer them either manually or via environment variable.
-    One known case is if you use unencrypted repositories, then it will ask
-    about a unknown unencrypted repository one time.
-  - your first backup with 1.1.x might be significantly slower (it might
-    completely read, chunk, hash a lot files) - this is due to the
-    --files-cache mode change (and happens every time you change mode).
-    You can avoid the one-time slowdown by using the pre-1.1.0rc4-compatible
-    mode (but that is less safe for detecting changed files than the default).
-    See the --files-cache docs for details.
-
-Fixes:
-
-- security fix: configure FUSE with "default_permissions", #3903
-  "default_permissions" is now enforced by borg by default to let the
-  kernel check uid/gid/mode based permissions.
-  "ignore_permissions" can be given to not enforce "default_permissions".
-- make "hostname" short, even on misconfigured systems, #4262
-- fix free space calculation on macOS (and others?), #4289
-- config: quit with error message when no key is provided, #4223
-- recover_segment: handle too small segment files correctly, #4272
-- correctly release memoryview, #4243
-- avoid diaper pattern in configparser by opening files, #4263
-- add "# cython: language_level=3" directive to .pyx files, #4214
-- info: consider part files for "This archive" stats, #3522
-- work around Microsoft WSL issue #645 (sync_file_range), #1961
-
-New features:
-
-- add --rsh command line option to complement BORG_RSH env var, #1701
-- init: --make-parent-dirs parent1/parent2/repo_dir, #4235
-
-Other:
-
-- add archive name to check --repair output, #3447
-- check for unsupported msgpack versions
-- shell completions:
-
-  - new shell completions for borg 1.1.9
-  - more complete shell completions for borg mount -o
-  - added shell completions for borg help
-  - option arguments for zsh tab completion
-- docs:
-
-  - add FAQ regarding free disk space check, #3905
-  - update BORG_PASSCOMMAND example and clarify variable expansion, #4249
-  - FAQ regarding change of compression settings, #4222
-  - add note about BSD flags to changelog, #4246
-  - improve logging in example automation script
-  - add note about files changing during backup, #4081
-  - work around the backslash issue, #4280
-  - update release workflow using twine (docs, scripts), #4213
-  - add warnings on repository copies to avoid future problems, #4272
-- tests:
-
-  - fix the homebrew 1.9 issues on travis-ci, #4254
-  - fix duplicate test method name, #4311
-
-
-Version 1.1.8 (2018-12-09)
---------------------------
-
-Fixes:
-
-- enforce storage quota if set by serve-command, #4093
-- invalid locations: give err msg containing parsed location, #4179
-- list repo: add placeholders for hostname and username, #4130
-- on linux, symlinks can't have ACLs, so don't try to set any, #4044
-
-New features:
-
-- create: added PATH::archive output on INFO log level
-- read a passphrase from a file descriptor specified in the
-  BORG_PASSPHRASE_FD environment variable.
-
-Other:
-
-- docs:
-
-  - option --format is required for some expensive-to-compute values for json
-
-    borg list by default does not compute expensive values except when
-    they are needed. whether they are needed is determined by the format,
-    in standard mode as well as in --json mode.
-  - tell that our binaries are x86/x64 amd/intel, bauerj has ARM
-  - fixed wrong archive name pattern in CRUD benchmark help
-  - fixed link to cachedir spec in docs, #4140
-- tests:
-
-  - stop using fakeroot on travis, avoids sporadic EISDIR errors, #2482
-  - xattr key names must start with "user." on linux
-  - fix code so flake8 3.6 does not complain
-  - explicitly convert environment variable to str, #4136
-  - fix DeprecationWarning: Flags not at the start of the expression, #4137
-  - support pytest4, #4172
-- vagrant:
-
-  - use python 3.5.6 for builds
-
-
-Version 1.1.7 (2018-08-11)
---------------------------
-
-Compatibility notes:
-
-- added support for Python 3.7
-
-Fixes:
-
-- cache lock: use lock_wait everywhere to fix infinite wait, see #3968
-- don't archive tagged dir when recursing an excluded dir, #3991
-- py37 argparse: work around bad default in py 3.7.0a/b/rc, #3996
-- py37 remove loggerDict.clear() from tearDown method, #3805
-- some fixes for bugs which likely did not result in problems in practice:
-
-  - fixed logic bug in platform module API version check
-  - fixed xattr/acl function prototypes, added missing ones
-
-New features:
-
-- init: add warning to store both key and passphrase at safe place(s)
-- BORG_HOST_ID env var to work around all-zero MAC address issue, #3985
-- borg debug dump-repo-objs --ghost (dump everything from segment files,
-  including deleted or superseded objects or commit tags)
-- borg debug search-repo-objs (search in repo objects for hex bytes or strings)
-
-Other changes:
-
-- add Python 3.7 support
-- updated shell completions
-- call socket.gethostname only once
-- locking: better logging, add some asserts
-- borg debug dump-repo-objs:
-
-  - filename layout improvements
-  - use repository.scan() to get on-disk order
-- docs:
-
-  - update installation instructions for macOS
-  - added instructions to install fuse via homebrew
-  - improve diff docs
-  - added note that checkpoints inside files requires 1.1+
-  - add link to tempfile module
-  - remove row/column-spanning from docs source, #4000 #3990
-- tests:
-
-  - fetch less data via os.urandom
-  - add py37 env for tox
-  - travis: add 3.7, remove 3.6-dev (we test with -dev in master)
-- vagrant / binary builds:
-
-  - use osxfuse 3.8.2
-  - use own (uptodate) openindiana box
-
-
-Version 1.1.6 (2018-06-11)
---------------------------
-
-Compatibility notes:
-
-- 1.1.6 changes:
-
-  - also allow msgpack-python 0.5.6.
-
-Fixes:
-
-- fix borg exception handling on ENOSPC error with xattrs, #3808
-- prune: fix/improve overall progress display
-- borg config repo ... does not need cache/manifest/key, #3802
-- debug dump-repo-objs should not depend on a manifest obj
-- pypi package:
-
-  - include .coveragerc, needed by tox.ini
-  - fix package long description, #3854
-
-New features:
-
-- mount: add uid, gid, umask mount options
-- delete:
-
-  - only commit once, #3823
-  - implement --dry-run, #3822
-- check:
-
-  - show progress while rebuilding missing manifest, #3787
-  - more --repair output
-- borg config --list <repo>, #3612
-
-Other changes:
-
-- update msgpack requirement, #3753
-- update bundled zstd to 1.3.4, #3745
-- update bundled lz4 code to 1.8.2, #3870
-- docs:
-
-  - describe what BORG_LIBZSTD_PREFIX does
-  - fix and deduplicate encryption quickstart docs, #3776
-- vagrant:
-
-  - FUSE for macOS: upgrade 3.7.1 to 3.8.0
-  - exclude macOS High Sierra upgrade on the darwin64 machine
-  - remove borgbackup.egg-info dir in fs_init (after rsync)
-  - use pyenv-based build/test on jessie32/62
-  - use local 32 and 64bit debian jessie boxes
-  - use "vagrant" as username for new xenial box
-- travis OS X: use xcode 8.3 (not broken)
-
-
-Version 1.1.5 (2018-04-01)
---------------------------
-
-Compatibility notes:
-
-- 1.1.5 changes:
-
-  - require msgpack-python >= 0.4.6 and < 0.5.0.
-    0.5.0+ dropped python 3.4 testing and also caused some other issues because
-    the python package was renamed to msgpack and emitted some FutureWarning.
-
-Fixes:
-
-- create --list: fix that it was never showing M status, #3492
-- create: fix timing for first checkpoint (read files cache early, init
-  checkpoint timer after that), see #3394
-- extract: set rc=1 when extracting damaged files with all-zero replacement
-  chunks or with size inconsistencies, #3448
-- diff: consider an empty file as different to a non-existing file, #3688
-- files cache: improve exception handling, #3553
-- ignore exceptions in scandir_inorder() caused by an implicit stat(),
-  also remove unneeded sort, #3545
-- fixed tab completion problem where a space is always added after path even
-  when it shouldn't
-- build: do .h file content checks in binary mode, fixes build issue for
-  non-ascii header files on pure-ascii locale platforms, #3544 #3639
-- borgfs: fix patterns/paths processing, #3551
-- config: add some validation, #3566
-- repository config: add validation for max_segment_size, #3592
-- set cache previous_location on load instead of save
-- remove platform.uname() call which caused library mismatch issues, #3732
-- add exception handler around deprecated platform.linux_distribution() call
-- use same datetime object for {now} and {utcnow}, #3548
-
-New features:
-
-- create: implement --stdin-name, #3533
-- add chunker_params to borg archive info (--json)
-- BORG_SHOW_SYSINFO=no to hide system information from exceptions
-
-Other changes:
-
-- updated zsh completions for borg 1.1.4
-- files cache related code cleanups
-- be more helpful when parsing invalid --pattern values, #3575
-- be more clear in secure-erase warning message, #3591
-- improve getpass user experience, #3689
-- docs build: unicode problem fixed when using a py27-based sphinx
-- docs:
-
-  - security: explicitly note what happens OUTSIDE the attack model
-  - security: add note about combining compression and encryption
-  - security: describe chunk size / proximity issue, #3687
-  - quickstart: add note about permissions, borg@localhost, #3452
-  - quickstart: add introduction to repositories & archives, #3620
-  - recreate --recompress: add missing metavar, clarify description, #3617
-  - improve logging docs, #3549
-  - add an example for --pattern usage, #3661
-  - clarify path semantics when matching, #3598
-  - link to offline documentation from README, #3502
-  - add docs on how to verify a signed release with GPG, #3634
-  - chunk seed is generated per repository (not: archive)
-  - better formatting of CPU usage documentation, #3554
-  - extend append-only repo rollback docs, #3579
-- tests:
-
-  - fix erroneously skipped zstd compressor tests, #3606
-  - skip a test if argparse is broken, #3705
-- vagrant:
-
-  - xenial64 box now uses username 'vagrant', #3707
-  - move cleanup steps to fs_init, #3706
-  - the boxcutter wheezy boxes are 404, use local ones
-  - update to Python 3.5.5 (for binary builds)
-
-
-Version 1.1.4 (2017-12-31)
---------------------------
-
-Compatibility notes:
-
-- When upgrading from borg 1.0.x to 1.1.x, please note:
-
-  - read all the compatibility notes for 1.1.0*, starting from 1.1.0b1.
-  - borg upgrade: you do not need to and you also should not run it.
-  - borg might ask some security-related questions once after upgrading.
-    You can answer them either manually or via environment variable.
-    One known case is if you use unencrypted repositories, then it will ask
-    about a unknown unencrypted repository one time.
-  - your first backup with 1.1.x might be significantly slower (it might
-    completely read, chunk, hash a lot files) - this is due to the
-    --files-cache mode change (and happens every time you change mode).
-    You can avoid the one-time slowdown by using the pre-1.1.0rc4-compatible
-    mode (but that is less safe for detecting changed files than the default).
-    See the --files-cache docs for details.
-- borg 1.1.4 changes:
-
-  - zstd compression is new in borg 1.1.4, older borg can't handle it.
-  - new minimum requirements for the compression libraries - if the required
-    versions (header and lib) can't be found at build time, bundled code will
-    be used:
-
-    - added requirement: libzstd >= 1.3.0 (bundled: 1.3.2)
-    - updated requirement: liblz4 >= 1.7.0 / r129 (bundled: 1.8.0)
-
-Fixes:
-
-- check: data corruption fix: fix for borg check --repair malfunction, #3444.
-  See the more detailed notes close to the top of this document.
-- delete: also delete security dir when deleting a repo, #3427
-- prune: fix building the "borg prune" man page, #3398
-- init: use given --storage-quota for local repo, #3470
-- init: properly quote repo path in output
-- fix startup delay with dns-only own fqdn resolving, #3471
-
-New features:
-
-- added zstd compression. try it!
-- added placeholder {reverse-fqdn} for fqdn in reverse notation
-- added BORG_BASE_DIR environment variable, #3338
-
-Other changes:
-
-- list help topics when invalid topic is requested
-- fix lz4 deprecation warning, requires lz4 >= 1.7.0 (r129)
-- add parens for C preprocessor macro argument usages (did not cause malfunction)
-- exclude broken pytest 3.3.0 release
-- updated fish/bash completions
-- init: more clear exception messages for borg create, #3465
-- docs:
-
-  - add auto-generated docs for borg config
-  - don't generate HTML docs page for borgfs, #3404
-  - docs update for lz4 b2 zstd changes
-  - add zstd to compression help, readme, docs
-  - update requirements and install docs about bundled lz4 and zstd
-- refactored build of the compress and crypto.low_level extensions, #3415:
-
-  - move some lib/build related code to setup_{zstd,lz4,b2}.py
-  - bundle lz4 1.8.0 (requirement: >= 1.7.0 / r129)
-  - bundle zstd 1.3.2 (requirement: >= 1.3.0)
-  - blake2 was already bundled
-  - rename BORG_LZ4_PREFIX env var to BORG_LIBLZ4_PREFIX for better consistency:
-    we also have BORG_LIBB2_PREFIX and BORG_LIBZSTD_PREFIX now.
-  - add prefer_system_lib* = True settings to setup.py - by default the build
-    will prefer a shared library over the bundled code, if library and headers
-    can be found and meet the minimum requirements.
-
-
-Version 1.1.3 (2017-11-27)
---------------------------
-
-Fixes:
-
-- Security Fix for CVE-2017-15914: Incorrect implementation of access controls
-  allows remote users to override repository restrictions in Borg servers.
-  A user able to access a remote Borg SSH server is able to circumvent access
-  controls post-authentication.
-  Affected releases: 1.1.0, 1.1.1, 1.1.2. Releases 1.0.x are NOT affected.
-- crc32: deal with unaligned buffer, add tests - this broke borg on older ARM
-  CPUs that can not deal with unaligned 32bit memory accesses and raise a bus
-  error in such cases. the fix might also improve performance on some CPUs as
-  all 32bit memory accesses by the crc32 code are properly aligned now. #3317
-- mount: fixed support of --consider-part-files and do not show .borg_part_N
-  files by default in the mounted FUSE filesystem. #3347
-- fixed cache/repo timestamp inconsistency message, highlight that information
-  is obtained from security dir (deleting the cache will not bypass this error
-  in case the user knows this is a legitimate repo).
-- borgfs: don't show sub-command in borgfs help, #3287
-- create: show an error when --dry-run and --stats are used together, #3298
-
-New features:
-
-- mount: added exclusion group options and paths, #2138
-
-  Reused some code to support similar options/paths as borg extract offers -
-  making good use of these to only mount a smaller subset of dirs/files can
-  speed up mounting a lot and also will consume way less memory.
-
-  borg mount [options] repo_or_archive mountpoint path [paths...]
-
-  paths: you can just give some "root paths" (like for borg extract) to
-  only partially populate the FUSE filesystem.
-
-  new options: --exclude[-from], --pattern[s-from], --strip-components
-- create/extract: support st_birthtime on platforms supporting it, #3272
-- add "borg config" command for querying/setting/deleting config values, #3304
-
-Other changes:
-
-- clean up and simplify packaging (only package committed files, do not install
-  .c/.h/.pyx files)
-- docs:
-
-  - point out tuning options for borg create, #3239
-  - add instructions for using ntfsclone, zerofree, #81
-  - move image backup-related FAQ entries to a new page
-  - clarify key aliases for borg list --format, #3111
-  - mention break-lock in checkpointing FAQ entry, #3328
-  - document sshfs rename workaround, #3315
-  - add FAQ about removing files from existing archives
-  - add FAQ about different prune policies
-  - usage and man page for borgfs, #3216
-  - clarify create --stats duration vs. wall time, #3301
-  - clarify encrypted key format for borg key export, #3296
-  - update release checklist about security fixes
-  - document good and problematic option placements, fix examples, #3356
-  - add note about using --nobsdflags to avoid speed penalty related to
-    bsdflags, #3239
-  - move most of support section to www.borgbackup.org
-
-
-Version 1.1.2 (2017-11-05)
---------------------------
-
-Fixes:
-
-- fix KeyError crash when talking to borg server < 1.0.7, #3244
-- extract: set bsdflags last (include immutable flag), #3263
-- create: don't do stat() call on excluded-norecurse directory, fix exception
-  handling for stat() call, #3209
-- create --stats: do not count data volume twice when checkpointing, #3224
-- recreate: move chunks_healthy when excluding hardlink master, #3228
-- recreate: get rid of chunks_healthy when rechunking (does not match), #3218
-- check: get rid of already existing not matching chunks_healthy metadata, #3218
-- list: fix stdout broken pipe handling, #3245
-- list/diff: remove tag-file options (not used), #3226
-
-New features:
-
-- bash, zsh and fish shell auto-completions, see scripts/shell_completions/
-- added BORG_CONFIG_DIR env var, #3083
-
-Other changes:
-
-- docs:
-
-  - clarify using a blank passphrase in keyfile mode
-  - mention "!" (exclude-norecurse) type in "patterns" help
-  - document to first heal before running borg recreate to re-chunk stuff,
-    because that will have to get rid of chunks_healthy metadata.
-  - more than 23 is not supported for CHUNK_MAX_EXP, #3115
-  - borg does not respect nodump flag by default any more
-  - clarify same-filesystem requirement for borg upgrade, #2083
-  - update / rephrase cygwin / WSL status, #3174
-  - improve docs about --stats, #3260
-- vagrant: openindiana new clang package
-
-Already contained in 1.1.1 (last minute fix):
-
-- arg parsing: fix fallback function, refactor, #3205. This is a fixup
-  for #3155, which was broken on at least python <= 3.4.2.
-
-
-Version 1.1.1 (2017-10-22)
---------------------------
-
-Compatibility notes:
-
-- The deprecated --no-files-cache is not a global/common option any more,
-  but only available for borg create (it is not needed for anything else).
-  Use --files-cache=disabled instead of --no-files-cache.
-- The nodump flag ("do not backup this file") is not honoured any more by
-  default because this functionality (esp. if it happened by error or
-  unexpected) was rather confusing and unexplainable at first to users.
-  If you want that "do not backup NODUMP-flagged files" behaviour, use:
-  borg create --exclude-nodump ...
-- If you are on Linux and do not need bsdflags archived, consider using
-  ``--nobsdflags`` with ``borg create`` to avoid additional syscalls and
-  speed up backup creation.
-
-Fixes:
-
-- borg recreate: correctly compute part file sizes. fixes cosmetic, but
-  annoying issue as borg check complains about size inconsistencies of part
-  files in affected archives. you can solve that by running borg recreate on
-  these archives, see also #3157.
-- bsdflags support: do not open BLK/CHR/LNK files, avoid crashes and
-  slowness, #3130
-- recreate: don't crash on attic archives w/o time_end, #3109
-- don't crash on repository filesystems w/o hardlink support, #3107
-- don't crash in first part of truncate_and_unlink, #3117
-- fix server-side IndexError crash with clients < 1.0.7, #3192
-- don't show traceback if only a global option is given, show help, #3142
-- cache: use SaveFile for more safety, #3158
-- init: fix wrong encryption choices in command line parser, fix missing
-  "authenticated-blake2", #3103
-- move --no-files-cache from common to borg create options, #3146
-- fix detection of non-local path (failed on ..filename), #3108
-- logging with fileConfig: set json attr on "borg" logger, #3114
-- fix crash with relative BORG_KEY_FILE, #3197
-- show excluded dir with "x" for tagged dirs / caches, #3189
-
-New features:
-
-- create: --nobsdflags and --exclude-nodump options, #3160
-- extract: --nobsdflags option, #3160
-
-Other changes:
-
-- remove annoying hardlinked symlinks warning, #3175
-- vagrant: use self-made FreeBSD 10.3 box, #3022
-- travis: don't brew update, hopefully fixes #2532
-- docs:
-
-  - readme: -e option is required in borg 1.1
-  - add example showing --show-version --show-rc
-  - use --format rather than --list-format (deprecated) in example
-  - update docs about hardlinked symlinks limitation
-
-
-Version 1.1.0 (2017-10-07)
---------------------------
-
-Compatibility notes:
-
-- borg command line: do not put options in between positional arguments
-
-  This sometimes works (e.g. it worked in borg 1.0.x), but can easily stop
-  working if we make positional arguments optional (like it happened for
-  borg create's "paths" argument in 1.1). There are also places in borg 1.0
-  where we do that, so it doesn't work there in general either. #3356
-
-  Good: borg create -v --stats repo::archive path
-  Good: borg create repo::archive path -v --stats
-  Bad:  borg create repo::archive -v --stats path
-
-Fixes:
-
-- fix LD_LIBRARY_PATH restoration for subprocesses, #3077
-- "auto" compression: make sure expensive compression is actually better,
-  otherwise store lz4 compressed data we already computed.
-
-Other changes:
-
-- docs:
-
-  - FAQ: we do not implement futile attempts of ETA / progress displays
-  - manpage: fix typos, update homepage
-  - implement simple "issue" role for manpage generation, #3075
-
-
-Version 1.1.0rc4 (2017-10-01)
------------------------------
-
-Compatibility notes:
-
-- A borg server >= 1.1.0rc4 does not support borg clients 1.1.0b3-b5. #3033
-- The files cache is now controlled differently and has a new default mode:
-
-  - the files cache now uses ctime by default for improved file change
-    detection safety. You can still use mtime for more speed and less safety.
-  - --ignore-inode is deprecated (use --files-cache=... without "inode")
-  - --no-files-cache is deprecated (use --files-cache=disabled)
-
-New features:
-
-- --files-cache - implement files cache mode control, #911
-  You can now control the files cache mode using this option:
-  --files-cache={ctime,mtime,size,inode,rechunk,disabled}
-  (only some combinations are supported). See the docs for details.
-
-Fixes:
-
-- remote progress/logging: deal with partial lines, #2637
-- remote progress: flush json mode output
-- fix subprocess environments, #3050 (and more)
-
-Other changes:
-
-- remove client_supports_log_v3 flag, #3033
-- exclude broken Cython 0.27(.0) in requirements, #3066
-- vagrant:
-
-  - upgrade to FUSE for macOS 3.7.1
-  - use Python 3.5.4 to build the binaries
-- docs:
-
-  - security: change-passphrase only changes the passphrase, #2990
-  - fixed/improved borg create --compression examples, #3034
-  - add note about metadata dedup and --no[ac]time, #2518
-  - twitter account @borgbackup now, better visible, #2948
-  - simplified rate limiting wrapper in FAQ
-
-
-Version 1.1.0rc3 (2017-09-10)
------------------------------
-
-New features:
-
-- delete: support naming multiple archives, #2958
-
-Fixes:
-
-- repo cleanup/write: invalidate cached FDs, #2982
-- fix datetime.isoformat() microseconds issues, #2994
-- recover_segment: use mmap(), lower memory needs, #2987
-
-Other changes:
-
-- with-lock: close segment file before invoking subprocess
-- keymanager: don't depend on optional readline module, #2976
-- docs:
-
-  - fix macOS keychain integration command
-  - show/link new screencasts in README, #2936
-  - document utf-8 locale requirement for json mode, #2273
-- vagrant: clean up shell profile init, user name, #2977
-- test_detect_attic_repo: don't test mount, #2975
-- add debug logging for repository cleanup
-
-
-Version 1.1.0rc2 (2017-08-28)
------------------------------
-
-Compatibility notes:
-
-- list: corrected mix-up of "isomtime" and "mtime" formats. Previously,
-  "isomtime" was the default but produced a verbose human format,
-  while "mtime" produced a ISO-8601-like format.
-  The behaviours have been swapped (so "mtime" is human, "isomtime" is ISO-like),
-  and the default is now "mtime".
-  "isomtime" is now a real ISO-8601 format ("T" between date and time, not a space).
-
-New features:
-
-- None.
-
-Fixes:
-
-- list: fix weird mixup of mtime/isomtime
-- create --timestamp: set start time, #2957
-- ignore corrupt files cache, #2939
-- migrate locks to child PID when daemonize is used
-- fix exitcode of borg serve, #2910
-- only compare contents when chunker params match, #2899
-- umount: try fusermount, then try umount, #2863
-
-Other changes:
-
-- JSON: use a more standard ISO 8601 datetime format, #2376
-- cache: write_archive_index: truncate_and_unlink on error, #2628
-- detect non-upgraded Attic repositories, #1933
-- delete various nogil and threading related lines
-- coala / pylint related improvements
-- docs:
-
-  - renew asciinema/screencasts, #669
-  - create: document exclusion through nodump, #2949
-  - minor formatting fixes
-  - tar: tarpipe example
-  - improve "with-lock" and "info" docs, #2869
-  - detail how to use macOS/GNOME/KDE keyrings for repo passwords, #392
-- travis: only short-circuit docs-only changes for pull requests
-- vagrant:
-
-  - netbsd: bash is already installed
-  - fix netbsd version in PKG_PATH
-  - add exe location to PATH when we build an exe
-
-
-Version 1.1.0rc1 (2017-07-24)
------------------------------
-
-Compatibility notes:
-
-- delete: removed short option for --cache-only
-
-New features:
-
-- support borg list repo --format {comment} {bcomment} {end}, #2081
-- key import: allow reading from stdin, #2760
-
-Fixes:
-
-- with-lock: avoid creating segment files that might be overwritten later, #1867
-- prune: fix checkpoints processing with --glob-archives
-- FUSE: versions view: keep original file extension at end, #2769
-- fix --last, --first: do not accept values <= 0,
-  fix reversed archive ordering with --last
-- include testsuite data (attic.tar.gz) when installing the package
-- use limited unpacker for outer key, for manifest (both security precautions),
-  #2174 #2175
-- fix bashism in shell scripts, #2820, #2816
-- cleanup endianness detection, create _endian.h,
-  fixes build on alpine linux, #2809
-- fix crash with --no-cache-sync (give known chunk size to chunk_incref), #2853
-
-Other changes:
-
-- FUSE: versions view: linear numbering by archive time
-- split up interval parsing from filtering for --keep-within, #2610
-- add a basic .editorconfig, #2734
-- use archive creation time as mtime for FUSE mount, #2834
-- upgrade FUSE for macOS (osxfuse) from 3.5.8 to 3.6.3, #2706
-- hashindex: speed up by replacing modulo with "if" to check for wraparound
-- coala checker / pylint: fixed requirements and .coafile, more ignores
-- borg upgrade: name backup directories as 'before-upgrade', #2811
-- add .mailmap
-- some minor changes suggested by lgtm.com
-- docs:
-
-  - better explanation of the --ignore-inode option relevance, #2800
-  - fix openSUSE command and add openSUSE section
-  - simplify ssh authorized_keys file using "restrict", add legacy note, #2121
-  - mount: show usage of archive filters
-  - mount: add repository example, #2462
-  - info: update and add examples, #2765
-  - prune: include example
-  - improved style / formatting
-  - improved/fixed segments_per_dir docs
-  - recreate: fix wrong "remove unwanted files" example
-  - reference list of status chars in borg recreate --filter description
-  - update source-install docs about doc build dependencies, #2795
-  - cleanup installation docs
-  - file system requirements, update segs per dir
-  - fix checkpoints/parts reference in FAQ, #2859
-- code:
-
-  - hashindex: don't pass side effect into macro
-  - crypto low_level: don't mutate local bytes()
-  - use dash_open function to open file or "-" for stdin/stdout
-  - archiver: argparse cleanup / refactoring
-  - shellpattern: add match_end arg
-- tests: added some additional unit tests, some fixes, #2700 #2710
-- vagrant: fix setup of cygwin, add Debian 9 "stretch"
-- travis: don't perform full travis build on docs-only changes, #2531
-
-
-Version 1.1.0b6 (2017-06-18)
-----------------------------
-
-Compatibility notes:
-
-- Running "borg init" via a "borg serve --append-only" server will *not* create
-  an append-only repository anymore. Use "borg init --append-only" to initialize
-  an append-only repository.
-
-- Repositories in the "repokey" and "repokey-blake2" modes with an empty passphrase
-  are now treated as unencrypted repositories for security checks (e.g.
-  BORG_UNKNOWN_UNENCRYPTED_REPO_ACCESS_IS_OK).
-
-  Previously there would be no prompts nor messages if an unknown repository
-  in one of these modes with an empty passphrase was encountered. This would
-  allow an attacker to swap a repository, if one assumed that the lack of
-  password prompts was due to a set BORG_PASSPHRASE.
-
-  Since the "trick" does not work if BORG_PASSPHRASE is set, this does generally
-  not affect scripts.
-
-- Repositories in the "authenticated" mode are now treated as the unencrypted
-  repositories they are.
-
-- The client-side temporary repository cache now holds unencrypted data for better speed.
-
-- borg init: removed the short form of --append-only (-a).
-
-- borg upgrade: removed the short form of --inplace (-i).
-
-New features:
-
-- reimplemented the RepositoryCache, size-limited caching of decrypted repo
-  contents, integrity checked via xxh64. #2515
-- reduced space usage of chunks.archive.d. Existing caches are migrated during
-  a cache sync. #235 #2638
-- integrity checking using xxh64 for important files used by borg, #1101:
-
-  - repository: index and hints files
-  - cache: chunks and files caches, chunks.archive.d
-- improve cache sync speed, #1729
-- create: new --no-cache-sync option
-- add repository mandatory feature flags infrastructure, #1806
-- Verify most operations against SecurityManager. Location, manifest timestamp
-  and key types are now checked for almost all non-debug commands. #2487
-- implement storage quotas, #2517
-- serve: add --restrict-to-repository, #2589
-- BORG_PASSCOMMAND: use external tool providing the key passphrase, #2573
-- borg export-tar, #2519
-- list: --json-lines instead of --json for archive contents, #2439
-- add --debug-profile option (and also "borg debug convert-profile"), #2473
-- implement --glob-archives/-a, #2448
-- normalize authenticated key modes for better naming consistency:
-
-  - rename "authenticated" to "authenticated-blake2" (uses blake2b)
-  - implement "authenticated" mode (uses hmac-sha256)
-
-Fixes:
-
-- hashindex: read/write indices >2 GiB on 32bit systems, better error
-  reporting, #2496
-- repository URLs: implement IPv6 address support and also more informative
-  error message when parsing fails.
-- mount: check whether llfuse is installed before asking for passphrase, #2540
-- mount: do pre-mount checks before opening repository, #2541
-- FUSE:
-
-  - fix crash if empty (None) xattr is read, #2534
-  - fix read(2) caching data in metadata cache
-  - fix negative uid/gid crash (fix crash when mounting archives
-    of external drives made on cygwin), #2674
-  - redo ItemCache, on top of object cache
-  - use decrypted cache
-  - remove unnecessary normpaths
-- serve: ignore --append-only when initializing a repository (borg init), #2501
-- serve: fix incorrect type of exception_short for Errors, #2513
-- fix --exclude and --exclude-from recursing into directories, #2469
-- init: don't allow creating nested repositories, #2563
-- --json: fix encryption[mode] not being the cmdline name
-- remote: propagate Error.traceback correctly
-- fix remote logging and progress, #2241
-
-  - implement --debug-topic for remote servers
-  - remote: restore "Remote:" prefix (as used in 1.0.x)
-  - rpc negotiate: enable v3 log protocol only for supported clients
-  - fix --progress and logging in general for remote
-- fix parse_version, add tests, #2556
-- repository: truncate segments (and also some other files) before unlinking, #2557
-- recreate: keep timestamps as in original archive, #2384
-- recreate: if single archive is not processed, exit 2
-- patterns: don't recurse with ! / --exclude for pf:, #2509
-- cache sync: fix n^2 behaviour in lookup_name
-- extract: don't write to disk with --stdout (affected non-regular-file items), #2645
-- hashindex: implement KeyError, more tests
-
-Other changes:
-
-- remote: show path in PathNotAllowed
-- consider repokey w/o passphrase == unencrypted, #2169
-- consider authenticated mode == unencrypted, #2503
-- restrict key file names, #2560
-- document follow_symlinks requirements, check libc, use stat and chown
-  with follow_symlinks=False, #2507
-- support common options on the main command, #2508
-- support common options on mid-level commands (e.g. borg *key* export)
-- make --progress a common option
-- increase DEFAULT_SEGMENTS_PER_DIR to 1000
-- chunker: fix invalid use of types (function only used by tests)
-- chunker: don't do uint32_t >> 32
-- FUSE:
-
-  - add instrumentation (--debug and SIGUSR1/SIGINFO)
-  - reduced memory usage for repository mounts by lazily instantiating archives
-  - improved archive load times
-- info: use CacheSynchronizer & HashIndex.stats_against (better performance)
-- docs:
-
-  - init: document --encryption as required
-  - security: OpenSSL usage
-  - security: used implementations; note python libraries
-  - security: security track record of OpenSSL and msgpack
-  - patterns: document denial of service (regex, wildcards)
-  - init: note possible denial of service with "none" mode
-  - init: document SHA extension is supported in OpenSSL and thus SHA is
-    faster on AMD Ryzen than blake2b.
-  - book: use A4 format, new builder option format.
-  - book: create appendices
-  - data structures: explain repository compaction
-  - data structures: add chunk layout diagram
-  - data structures: integrity checking
-  - data structures: demingle cache and repo index
-  - Attic FAQ: separate section for attic stuff
-  - FAQ: I get an IntegrityError or similar - what now?
-  - FAQ: Can I use Borg on SMR hard drives?, #2252
-  - FAQ: specify "using inline shell scripts"
-  - add systemd warning regarding placeholders, #2543
-  - xattr: document API
-  - add docs/misc/borg-data-flow data flow chart
-  - debugging facilities
-  - README: how to help the project, #2550
-  - README: add bountysource badge, #2558
-  - fresh new theme + tweaking
-  - logo: vectorized (PDF and SVG) versions
-  - frontends: use headlines - you can link to them
-  - mark --pattern, --patterns-from as experimental
-  - highlight experimental features in online docs
-  - remove regex based pattern examples, #2458
-  - nanorst for "borg help TOPIC" and --help
-  - split deployment
-  - deployment: hosting repositories
-  - deployment: automated backups to a local hard drive
-  - development: vagrant, windows10 requirements
-  - development: update docs remarks
-  - split usage docs, #2627
-  - usage: avoid bash highlight, [options] instead of <options>
-  - usage: add benchmark page
-  - helpers: truncate_and_unlink doc
-  - don't suggest to leak BORG_PASSPHRASE
-  - internals: columnize rather long ToC [webkit fixup]
-    internals: manifest & feature flags
-  - internals: more HashIndex details
-  - internals: fix ASCII art equations
-  - internals: edited obj graph related sections a bit
-  - internals: layers image + description
-  - fix way too small figures in pdf
-  - index: disable syntax highlight (bash)
-  - improve options formatting, fix accidental block quotes
-
-- testing / checking:
-
-  - add support for using coala, #1366
-  - testsuite: add ArchiverCorruptionTestCase
-  - do not test logger name, #2504
-  - call setup_logging after destroying logging config
-  - testsuite.archiver: normalise pytest.raises vs. assert_raises
-  - add test for preserved intermediate folder permissions, #2477
-  - key: add round-trip test
-  - remove attic dependency of the tests, #2505
-  - enable remote tests on cygwin
-  - tests: suppress tar's future timestamp warning
-  - cache sync: add more refcount tests
-  - repository: add tests, including corruption tests
-
-- vagrant:
-
-  - control VM cpus and pytest workers via env vars VMCPUS and XDISTN
-  - update cleaning workdir
-  - fix openbsd shell
-  - add OpenIndiana
-
-- packaging:
-
-  - binaries: don't bundle libssl
-  - setup.py clean to remove compiled files
-  - fail in borg package if version metadata is very broken (setuptools_scm)
-
-- repo / code structure:
-
-  - create borg.algorithms and borg.crypto packages
-  - algorithms: rename crc32 to checksums
-  - move patterns to module, #2469
-  - gitignore: complete paths for src/ excludes
-  - cache: extract CacheConfig class
-  - implement IntegrityCheckedFile + Detached variant, #2502 #1688
-  - introduce popen_with_error_handling to handle common user errors
-
-
-Version 1.1.0b5 (2017-04-30)
-----------------------------
-
-Compatibility notes:
-
-- BORG_HOSTNAME_IS_UNIQUE is now on by default.
-- removed --compression-from feature
-- recreate: add --recompress flag, unify --always-recompress and
-  --recompress
-
-Fixes:
-
-- catch exception for os.link when hardlinks are not supported, #2405
-- borg rename / recreate: expand placeholders, #2386
-- generic support for hardlinks (files, devices, FIFOs), #2324
-- extract: also create parent dir for device files, if needed, #2358
-- extract: if a hardlink master is not in the to-be-extracted subset,
-  the "x" status was not displayed for it, #2351
-- embrace y2038 issue to support 32bit platforms: clamp timestamps to int32,
-  #2347
-- verify_data: fix IntegrityError handling for defect chunks, #2442
-- allow excluding parent and including child, #2314
-
-Other changes:
-
-- refactor compression decision stuff
-- change global compression default to lz4 as well, to be consistent
-  with --compression defaults.
-- placeholders: deny access to internals and other unspecified stuff
-- clearer error message for unrecognized placeholder
-- more clear exception if borg check does not help, #2427
-- vagrant: upgrade FUSE for macOS to 3.5.8, #2346
-- linux binary builds: get rid of glibc 2.13 dependency, #2430
-- docs:
-
-  - placeholders: document escaping
-  - serve: env vars in original commands are ignored
-  - tell what kind of hardlinks we support
-  - more docs about compression
-  - LICENSE: use canonical formulation
-    ("copyright holders and contributors" instead of "author")
-  - document borg init behaviour via append-only borg serve, #2440
-  - be clear about what buzhash is used for, #2390
-  - add hint about chunker params, #2421
-  - clarify borg upgrade docs, #2436
-  - FAQ to explain warning when running borg check --repair, #2341
-  - repository file system requirements, #2080
-  - pre-install considerations
-  - misc. formatting / crossref fixes
-- tests:
-
-  - enhance travis setuptools_scm situation
-  - add extra test for the hashindex
-  - fix invalid param issue in benchmarks
-
-These belong to 1.1.0b4 release, but did not make it into changelog by then:
-
-- vagrant: increase memory for parallel testing
-- lz4 compress: lower max. buffer size, exception handling
-- add docstring to do_benchmark_crud
-- patterns help: mention path full-match in intro
-
-
-Version 1.1.0b4 (2017-03-27)
-----------------------------
-
-Compatibility notes:
-
-- init: the --encryption argument is mandatory now (there are several choices)
-- moved "borg migrate-to-repokey" to "borg key migrate-to-repokey".
-- "borg change-passphrase" is deprecated, use "borg key change-passphrase"
-  instead.
-- the --exclude-if-present option now supports tagging a folder with any
-  filesystem object type (file, folder, etc), instead of expecting only files
-  as tags, #1999
-- the --keep-tag-files option has been deprecated in favor of the new
-  --keep-exclude-tags, to account for the change mentioned above.
-- use lz4 compression by default, #2179
-
-New features:
-
-- JSON API to make developing frontends and automation easier
-  (see :ref:`json_output`)
-
-  - add JSON output to commands: `borg create/list/info --json ...`.
-  - add --log-json option for structured logging output.
-  - add JSON progress information, JSON support for confirmations (yes()).
-- add two new options --pattern and --patterns-from as discussed in #1406
-- new path full match pattern style (pf:) for very fast matching, #2334
-- add 'debug dump-manifest' and 'debug dump-archive' commands
-- add 'borg benchmark crud' command, #1788
-- new 'borg delete --force --force' to delete severely corrupted archives, #1975
-- info: show utilization of maximum archive size, #1452
-- list: add dsize and dcsize keys, #2164
-- paperkey.html: Add interactive html template for printing key backups.
-- key export: add qr html export mode
-- securely erase config file (which might have old encryption key), #2257
-- archived file items: add size to metadata, 'borg extract' and 'borg check' do
-  check the file size for consistency, FUSE uses precomputed size from Item.
-
-Fixes:
-
-- fix remote speed regression introduced in 1.1.0b3, #2185
-- fix regression handling timestamps beyond 2262 (revert bigint removal),
-  introduced in 1.1.0b3, #2321
-- clamp (nano)second values to unproblematic range, #2304
-- hashindex: rebuild hashtable if we have too little empty buckets
-  (performance fix), #2246
-- Location regex: fix bad parsing of wrong syntax
-- ignore posix_fadvise errors in repository.py, #2095
-- borg rpc: use limited msgpack.Unpacker (security precaution), #2139
-- Manifest: Make sure manifest timestamp is strictly monotonically increasing.
-- create: handle BackupOSError on a per-path level in one spot
-- create: clarify -x option / meaning of "same filesystem"
-- create: don't create hard link refs to failed files
-- archive check: detect and fix missing all-zero replacement chunks, #2180
-- files cache: update inode number when --ignore-inode is used, #2226
-- fix decompression exceptions crashing ``check --verify-data`` and others
-  instead of reporting integrity error, #2224 #2221
-- extract: warning for unextracted big extended attributes, #2258, #2161
-- mount: umount on SIGINT/^C when in foreground
-- mount: handle invalid hard link refs
-- mount: fix huge RAM consumption when mounting a repository (saves number of
-  archives * 8 MiB), #2308
-- hashindex: detect mingw byte order #2073
-- hashindex: fix wrong skip_hint on hashindex_set when encountering tombstones,
-  the regression was introduced in #1748
-- fix ChunkIndex.__contains__ assertion  for big-endian archs
-- fix borg key/debug/benchmark crashing without subcommand, #2240
-- Location: accept //servername/share/path
-- correct/refactor calculation of unique/non-unique chunks
-- extract: fix missing call to ProgressIndicator.finish
-- prune: fix error msg, it is --keep-within, not --within
-- fix "auto" compression mode bug (not compressing), #2331
-- fix symlink item fs size computation, #2344
-
-Other changes:
-
-- remote repository: improved async exception processing, #2255 #2225
-- with --compression auto,C, only use C if lz4 achieves at least 3% compression
-- PatternMatcher: only normalize path once, #2338
-- hashindex: separate endian-dependent defs from endian detection
-- migrate-to-repokey: ask using canonical_path() as we do everywhere else.
-- SyncFile: fix use of fd object after close
-- make LoggedIO.close_segment reentrant
-- creating a new segment: use "xb" mode, #2099
-- redo key_creator, key_factory, centralise key knowledge, #2272
-- add return code functions, #2199
-- list: only load cache if needed
-- list: files->items, clarifications
-- list: add "name" key for consistency with info cmd
-- ArchiveFormatter: add "start" key for compatibility with "info"
-- RemoteRepository: account rx/tx bytes
-- setup.py build_usage/build_man/build_api fixes
-- Manifest.in: simplify, exclude .so, .dll and .orig, #2066
-- FUSE: get rid of chunk accounting, st_blocks = ceil(size / blocksize).
-- tests:
-
-  - help python development by testing 3.6-dev
-  - test for borg delete --force
-- vagrant:
-
-  - freebsd: some fixes, #2067
-  - darwin64: use osxfuse 3.5.4 for tests / to build binaries
-  - darwin64: improve VM settings
-  - use python 3.5.3 to build binaries, #2078
-  - upgrade pyinstaller from 3.1.1+ to 3.2.1
-  - pyinstaller: use fixed AND freshly compiled bootloader, #2002
-  - pyinstaller: automatically builds bootloader if missing
-- docs:
-
-  - create really nice man pages
-  - faq: mention --remote-ratelimit in bandwidth limit question
-  - fix caskroom link, #2299
-  - docs/security: reiterate that RPC in Borg does no networking
-  - docs/security: counter tracking, #2266
-  - docs/development: update merge remarks
-  - address SSH batch mode in docs, #2202 #2270
-  - add warning about running build_usage on Python >3.4, #2123
-  - one link per distro in the installation page
-  - improve --exclude-if-present and --keep-exclude-tags, #2268
-  - improve automated backup script in doc, #2214
-  - improve remote-path description
-  - update docs for create -C default change (lz4)
-  - document relative path usage, #1868
-  - document snapshot usage, #2178
-  - corrected some stuff in internals+security
-  - internals: move toctree to after the introduction text
-  - clarify metadata kind, manifest ops
-  - key enc: correct / clarify some stuff, link to internals/security
-  - datas: enc: 1.1.x mas different MACs
-  - datas: enc: correct factual error -- no nonce involved there.
-  - make internals.rst an index page and edit it a bit
-  - add "Cryptography in Borg" and "Remote RPC protocol security" sections
-  - document BORG_HOSTNAME_IS_UNIQUE, #2087
-  - FAQ by categories as proposed by @anarcat in #1802
-  - FAQ: update Which file types, attributes, etc. are *not* preserved?
-  - development: new branching model for git repository
-  - development: define "ours" merge strategy for auto-generated files
-  - create: move --exclude note to main doc
-  - create: move item flags to main doc
-  - fix examples using borg init without -e/--encryption
-  - list: don't print key listings in fat (html + man)
-  - remove Python API docs (were very incomplete, build problems on RTFD)
-  - added FAQ section about backing up root partition
-
-
-Version 1.1.0b3 (2017-01-15)
-----------------------------
-
-Compatibility notes:
-
-- borg init: removed the default of "--encryption/-e", #1979
-  This was done so users do a informed decision about -e mode.
-
-Bug fixes:
-
-- borg recreate: don't rechunkify unless explicitly told so
-- borg info: fixed bug when called without arguments, #1914
-- borg init: fix free space check crashing if disk is full, #1821
-- borg debug delete/get obj: fix wrong reference to exception
-- fix processing of remote ~/ and ~user/ paths (regressed since 1.1.0b1), #1759
-- posix platform module: only build / import on non-win32 platforms, #2041
-
-New features:
-
-- new CRC32 implementations that are much faster than the zlib one used previously, #1970
-- add blake2b key modes (use blake2b as MAC). This links against system libb2,
-  if possible, otherwise uses bundled code
-- automatically remove stale locks - set BORG_HOSTNAME_IS_UNIQUE env var
-  to enable stale lock killing. If set, stale locks in both cache and
-  repository are deleted. #562 #1253
-- borg info <repo>: print general repo information, #1680
-- borg check --first / --last / --sort / --prefix, #1663
-- borg mount --first / --last / --sort / --prefix, #1542
-- implement "health" item formatter key, #1749
-- BORG_SECURITY_DIR to remember security related infos outside the cache.
-  Key type, location and manifest timestamp checks now survive cache
-  deletion. This also means that you can now delete your cache and avoid
-  previous warnings, since Borg can still tell it's safe.
-- implement BORG_NEW_PASSPHRASE, #1768
-
-Other changes:
-
-- borg recreate:
-
-  - remove special-cased --dry-run
-  - update --help
-  - remove bloat: interruption blah, autocommit blah, resuming blah
-  - re-use existing checkpoint functionality
-  - archiver tests: add check_cache tool - lints refcounts
-
-- fixed cache sync performance regression from 1.1.0b1 onwards, #1940
-- syncing the cache without chunks.archive.d (see :ref:`disable_archive_chunks`)
-  now avoids any merges and is thus faster, #1940
-- borg check --verify-data: faster due to linear on-disk-order scan
-- borg debug-xxx commands removed, we use "debug xxx" subcommands now, #1627
-- improve metadata handling speed
-- shortcut hashindex_set by having hashindex_lookup hint about address
-- improve / add progress displays, #1721
-- check for index vs. segment files object count mismatch
-- make RPC protocol more extensible: use named parameters.
-- RemoteRepository: misc. code cleanups / refactors
-- clarify cache/repository README file
-
-- docs:
-
-  - quickstart: add a comment about other (remote) filesystems
-  - quickstart: only give one possible ssh url syntax, all others are
-    documented in usage chapter.
-  - mention file://
-  - document repo URLs / archive location
-  - clarify borg diff help, #980
-  - deployment: synthesize alternative --restrict-to-path example
-  - improve cache / index docs, esp. files cache docs, #1825
-  - document using "git merge 1.0-maint -s recursive -X rename-threshold=20%"
-    for avoiding troubles when merging the 1.0-maint branch into master.
-
-- tests:
-
-  - FUSE tests: catch ENOTSUP on freebsd
-  - FUSE tests: test troublesome xattrs last
-  - fix byte range error in test, #1740
-  - use monkeypatch to set env vars, but only on pytest based tests.
-  - point XDG_*_HOME to temp dirs for tests, #1714
-  - remove all BORG_* env vars from the outer environment
-
-
-Version 1.1.0b2 (2016-10-01)
-----------------------------
-
-Bug fixes:
-
-- fix incorrect preservation of delete tags, leading to "object count mismatch"
-  on borg check, #1598. This only occurred with 1.1.0b1 (not with 1.0.x) and is
-  normally fixed by running another borg create/delete/prune.
-- fix broken --progress for double-cell paths (e.g. CJK), #1624
-- borg recreate: also catch SIGHUP
-- FUSE:
-
-  - fix hardlinks in versions view, #1599
-  - add parameter check to ItemCache.get to make potential failures more clear
-
-New features:
-
-- Archiver, RemoteRepository: add --remote-ratelimit (send data)
-- borg help compression, #1582
-- borg check: delete chunks with integrity errors, #1575, so they can be
-  "repaired" immediately and maybe healed later.
-- archives filters concept (refactoring/unifying older code)
-
-  - covers --first/--last/--prefix/--sort-by options
-  - currently used for borg list/info/delete
-
-Other changes:
-
-- borg check --verify-data slightly tuned (use get_many())
-- change {utcnow} and {now} to ISO-8601 format ("T" date/time separator)
-- repo check: log transaction IDs, improve object count mismatch diagnostic
-- Vagrantfile: use TW's fresh-bootloader pyinstaller branch
-- fix module names in api.rst
-- hashindex: bump api_version
-
-
-Version 1.1.0b1 (2016-08-28)
-----------------------------
-
-New features:
-
-- new commands:
-
-  - borg recreate: re-create existing archives, #787 #686 #630 #70, also see
-    #757, #770.
-
-    - selectively remove files/dirs from old archives
-    - re-compress data
-    - re-chunkify data, e.g. to have upgraded Attic / Borg 0.xx archives
-      deduplicate with Borg 1.x archives or to experiment with chunker-params.
-  - borg diff: show differences between archives
-  - borg with-lock: execute a command with the repository locked, #990
-- borg create:
-
-  - Flexible compression with pattern matching on path/filename,
-    and LZ4 heuristic for deciding compressibility, #810, #1007
-  - visit files in inode order (better speed, esp. for large directories and rotating disks)
-  - in-file checkpoints, #1217
-  - increased default checkpoint interval to 30 minutes (was 5 minutes), #896
-  - added uuid archive format tag, #1151
-  - save mountpoint directories with --one-file-system, makes system restore easier, #1033
-  - Linux: added support for some BSD flags, #1050
-  - add 'x' status for excluded paths, #814
-
-    - also means files excluded via UF_NODUMP, #1080
-- borg check:
-
-  - will not produce the "Checking segments" output unless new --progress option is passed, #824.
-  - --verify-data to verify data cryptographically on the client, #975
-- borg list, #751, #1179
-
-  - removed {formatkeys}, see "borg list --help"
-  - --list-format is deprecated, use --format instead
-  - --format now also applies to listing archives, not only archive contents, #1179
-  - now supports the usual [PATH [PATHS…]] syntax and excludes
-  - new keys: csize, num_chunks, unique_chunks, NUL
-  - supports guaranteed_available hashlib hashes
-    (to avoid varying functionality depending on environment),
-    which includes the SHA1 and SHA2 family as well as MD5
-- borg prune:
-
-  - to better visualize the "thinning out", we now list all archives in
-    reverse time order. rephrase and reorder help text.
-  - implement --keep-last N via --keep-secondly N, also --keep-minutely.
-    assuming that there is not more than 1 backup archive made in 1s,
-    --keep-last N and --keep-secondly N are equivalent, #537
-  - cleanup checkpoints except the latest, #1008
-- borg extract:
-
-  - added --progress, #1449
-  - Linux: limited support for BSD flags, #1050
-- borg info:
-
-  - output is now more similar to borg create --stats, #977
-- borg mount:
-
-  - provide "borgfs" wrapper for borg mount, enables usage via fstab, #743
-  - "versions" mount option - when used with a repository mount, this gives
-    a merged, versioned view of the files in all archives, #729
-- repository:
-
-  - added progress information to commit/compaction phase (often takes some time when deleting/pruning), #1519
-  - automatic recovery for some forms of repository inconsistency, #858
-  - check free space before going forward with a commit, #1336
-  - improved write performance (esp. for rotating media), #985
-
-    - new IO code for Linux
-    - raised default segment size to approx 512 MiB
-  - improved compaction performance, #1041
-  - reduced client CPU load and improved performance for remote repositories, #940
-
-- options that imply output (--show-rc, --show-version, --list, --stats,
-  --progress) don't need -v/--info to have that output displayed, #865
-- add archive comments (via borg (re)create --comment), #842
-- borg list/prune/delete: also output archive id, #731
-- --show-version: shows/logs the borg version, #725
-- added --debug-topic for granular debug logging, #1447
-- use atomic file writing/updating for configuration and key files, #1377
-- BORG_KEY_FILE environment variable, #1001
-- self-testing module, #970
-
-
-Bug fixes:
-
-- list: fixed default output being produced if --format is given with empty parameter, #1489
-- create: fixed overflowing progress line with CJK and similar characters, #1051
-- prune: fixed crash if --prefix resulted in no matches, #1029
-- init: clean up partial repo if passphrase input is aborted, #850
-- info: quote cmdline arguments that have spaces in them
-- fix hardlinks failing in some cases for extracting subtrees, #761
-
-Other changes:
-
-- replace stdlib hmac with OpenSSL, zero-copy decrypt (10-15% increase in
-  performance of hash-lists and extract).
-- improved chunker performance, #1021
-- open repository segment files in exclusive mode (fail-safe), #1134
-- improved error logging, #1440
-- Source:
-
-  - pass meta-data around, #765
-  - move some constants to new constants module
-  - better readability and fewer errors with namedtuples, #823
-  - moved source tree into src/ subdirectory, #1016
-  - made borg.platform a package, #1113
-  - removed dead crypto code, #1032
-  - improved and ported parts of the test suite to py.test, #912
-  - created data classes instead of passing dictionaries around, #981, #1158, #1161
-  - cleaned up imports, #1112
-- Docs:
-
-  - better help texts and sphinx reproduction of usage help:
-
-    - Group options
-    - Nicer list of options in Sphinx
-    - Deduplicate 'Common options' (including --help)
-  - chunker: added some insights by "Voltara", #903
-  - clarify what "deduplicated size" means
-  - fix / update / add package list entries
-  - added a SaltStack usage example, #956
-  - expanded FAQ
-  - new contributors in AUTHORS!
-- Tests:
-
-  - vagrant: add ubuntu/xenial 64bit - this box has still some issues
-  - ChunkBuffer: add test for leaving partial chunk in buffer, fixes #945
-
-
-Version 1.0.13 (2019-02-15)
----------------------------
-
-Please note: this is very likely the last 1.0.x release, please upgrade to 1.1.x.
-
-Bug fixes:
-
-- security fix: configure FUSE with "default_permissions", #3903.
-  "default_permissions" is now enforced by borg by default to let the
-  kernel check uid/gid/mode based permissions.
-  "ignore_permissions" can be given to not enforce "default_permissions".
-- xattrs: fix borg exception handling on ENOSPC error, #3808.
-
-New features:
-
-- Read a passphrase from a file descriptor specified in the
-  BORG_PASSPHRASE_FD environment variable.
-
-Other changes:
-
-- acl platform code: fix acl set return type
-- xattr:
-
-  - add linux {list,get,set}xattr ctypes prototypes
-  - fix darwin flistxattr ctypes prototype
-- testing / travis-ci:
-
-  - fix the homebrew 1.9 issues on travis-ci, #4254
-  - travis OS X: use xcode 8.3 (not broken)
-  - tox.ini: lock requirements
-  - unbreak 1.0-maint on travis, fixes #4123
-- vagrant:
-
-  - misc. fixes
-  - FUSE for macOS: upgrade 3.7.1 to 3.8.3
-  - Python: upgrade 3.5.5 to 3.5.6
-- docs:
-
-  - Update installation instructions for macOS
-  - update release workflow using twine (docs, scripts), #4213
-
-Version 1.0.12 (2018-04-08)
----------------------------
-
-Bug fixes:
-
-- repository: cleanup/write: invalidate cached FDs, tests
-- serve: fix exitcode, #2910
-- extract: set bsdflags last (include immutable flag), #3263
-- create --timestamp: set start time, #2957
-- create: show excluded dir with "x" for tagged dirs / caches, #3189
-- migrate locks to child PID when daemonize is used
-- Buffer: fix wrong thread-local storage use, #2951
-- fix detection of non-local path, #3108
-- fix LDLP restoration for subprocesses, #3077
-- fix subprocess environments (xattr module's fakeroot version check,
-  borg umount, BORG_PASSCOMMAND), #3050
-- remote: deal with partial lines, #2637
-- get rid of datetime.isoformat, use safe parse_timestamp to parse
-  timestamps, #2994
-- build: do .h file content checks in binary mode, fixes build issue for
-  non-ascii header files on pure-ascii locale platforms, #3544 #3639
-- remove platform.uname() call which caused library mismatch issues, #3732
-- add exception handler around deprecated platform.linux_distribution() call
-
-Other changes:
-
-- require msgpack-python >= 0.4.6 and < 0.5.0, see #3753
-- add parens for C preprocessor macro argument usages (did not cause
-  malfunction)
-- ignore corrupt files cache, #2939
-- replace "modulo" with "if" to check for wraparound in hashmap
-- keymanager: don't depend on optional readline module, #2980
-- exclude broken pytest 3.3.0 release
-- exclude broken Cython 0.27(.0) release, #3066
-- flake8: add some ignores
-- docs:
-
-  - create: document exclusion through nodump
-  - document good and problematic option placements, fix examples, #3356
-  - update docs about hardlinked symlinks limitation
-  - faq: we do not implement futile attempts of ETA / progress displays
-  - simplified rate limiting wrapper in FAQ
-  - twitter account @borgbackup, #2948
-  - add note about metadata dedup and --no[ac]time, #2518
-  - change-passphrase only changes the passphrase, #2990
-  - clarify encrypted key format for borg key export, #3296
-  - document sshfs rename workaround, #3315
-  - update release checklist about security fixes
-  - docs about how to verify a signed release, #3634
-  - chunk seed is generated per /repository/
-- vagrant:
-
-  - use FUSE for macOS 3.7.1 to build the macOS binary
-  - use python 3.5.5 to build the binaries
-  - add exe location to PATH when we build an exe
-  - use https pypi url for wheezy
-  - netbsd: bash is already installed
-  - netbsd: fix netbsd version in PKG_PATH
-  - use self-made FreeBSD 10.3 box, #3022
-  - backport fs_init (including related updates) from 1.1
-  - the boxcutter wheezy boxes are 404, use local ones
-- travis:
-
-  - don't perform full Travis build on docs-only changes, #2531
-  - only short-circuit docs-only changes for pull requests
-
-
-Version 1.0.11 (2017-07-21)
----------------------------
-
-Bug fixes:
-
-- use limited unpacker for outer key (security precaution), #2174
-- fix paperkey import bug
-
-Other changes:
-
-- change --checkpoint-interval default from 600s to 1800s, #2841.
-  this improves efficiency for big repositories a lot.
-- docs: fix OpenSUSE command and add OpenSUSE section
-- tests: add tests for split_lstring and paperkey
-- vagrant:
-
-  - fix openbsd shell
-  - backport cpu/ram setup from master
-  - add stretch64 VM
-
-Version 1.0.11rc1 (2017-06-27)
-------------------------------
-
-Bug fixes:
-
-- performance: rebuild hashtable if we have too few empty buckets, #2246.
-  this fixes some sporadic, but severe performance breakdowns.
-- Archive: allocate zeros when needed, #2308
-  fixes huge memory usage of mount (8 MiB × number of archives)
-- IPv6 address support
-  also: Location: more informative exception when parsing fails
-- borg single-file binary: use pyinstaller v3.2.1, #2396
-  this fixes that the prelink cronjob on some distros kills the
-  borg binary by stripping away parts of it.
-- extract:
-
-  - warning for unextracted big extended attributes, #2258
-  - also create parent dir for device files, if needed.
-  - don't write to disk with --stdout, #2645
-- archive check: detect and fix missing all-zero replacement chunks, #2180
-- fix (de)compression exceptions, #2224 #2221
-- files cache: update inode number, #2226
-- borg rpc: use limited msgpack.Unpacker (security precaution), #2139
-- Manifest: use limited msgpack.Unpacker (security precaution), #2175
-- Location: accept //servername/share/path
-- fix ChunkIndex.__contains__ assertion  for big-endian archs (harmless)
-- create: handle BackupOSError on a per-path level in one spot
-- fix error msg, there is no --keep-last in borg 1.0.x, #2282
-- clamp (nano)second values to unproblematic range, #2304
-- fuse / borg mount:
-
-  - fix st_blocks to be an integer (not float) value
-  - fix negative uid/gid crash (they could come into archives e.g. when
-    backing up external drives under cygwin), #2674
-  - fix crash if empty (None) xattr is read
-  - do pre-mount checks before opening repository
-  - check llfuse is installed before asking for passphrase
-- borg rename: expand placeholders, #2386
-- borg serve: fix forced command lines containing BORG_* env vars
-- fix error msg, it is --keep-within, not --within
-- fix borg key/debug/benchmark crashing without subcommand, #2240
-- chunker: fix invalid use of types, don't do uint32_t >> 32
-- document follow_symlinks requirements, check libc, #2507
-
-New features:
-
-- added BORG_PASSCOMMAND environment variable, #2573
-- add minimal version of in repository mandatory feature flags, #2134
-
-  This should allow us to make sure older borg versions can be cleanly
-  prevented from doing operations that are no longer safe because of
-  repository format evolution. This allows more fine grained control than
-  just incrementing the manifest version. So for example a change that
-  still allows new archives to be created but would corrupt the repository
-  when an old version tries to delete an archive or check the repository
-  would add the new feature to the check and delete set but leave it out
-  of the write set.
-- borg delete --force --force to delete severely corrupted archives, #1975
-
-Other changes:
-
-- embrace y2038 issue to support 32bit platforms
-- be more clear that this is a "beyond repair" case, #2427
-- key file names: limit to 100 characters and remove colons from host name
-- upgrade FUSE for macOS to 3.5.8, #2346
-- split up parsing and filtering for --keep-within, better error message, #2610
-- docs:
-
-  - fix caskroom link, #2299
-  - address SSH batch mode, #2202 #2270
-  - improve remote-path description
-  - document snapshot usage, #2178
-  - document relative path usage, #1868
-  - one link per distro in the installation page
-  - development: new branching model in git repository
-  - kill api page
-  - added FAQ section about backing up root partition
-  - add bountysource badge, #2558
-  - create empty docs.txt reequirements, #2694
-  - README: how to help the project
-  - note -v/--verbose requirement on affected options, #2542
-  - document borg init behaviour via append-only borg serve, #2440
-  - be clear about what buzhash is used for (chunking) and want it is not
-    used for (deduplication)- also say already in the readme that we use a
-    cryptohash for dedupe, so people don't worry, #2390
-  - add hint about chunker params to borg upgrade docs, #2421
-  - clarify borg upgrade docs, #2436
-  - quickstart: delete problematic BORG_PASSPHRASE use, #2623
-  - faq: specify "using inline shell scripts"
-  - document pattern denial of service, #2624
-- tests:
-
-  - remove attic dependency of the tests, #2505
-  - travis:
-
-    - enhance travis setuptools_scm situation
-    - install fakeroot for Linux
-  - add test for borg delete --force
-  - enable remote tests on cygwin (the cygwin issue that caused these tests
-    to break was fixed in cygwin at least since cygwin 2.8, maybe even since
-    2.7.0).
-  - remove skipping the noatime tests on GNU/Hurd, #2710
-  - fix borg import issue, add comment, #2718
-  - include attic.tar.gz when installing the package
-    also: add include_package_data=True
-
-Version 1.0.10 (2017-02-13)
----------------------------
-
-Bug fixes:
-
-- Manifest timestamps are now monotonically increasing,
-  this fixes issues when the system clock jumps backwards
-  or is set inconsistently across computers accessing the same repository, #2115
-- Fixed testing regression in 1.0.10rc1 that lead to a hard dependency on
-  py.test >= 3.0, #2112
-
-New features:
-
-- "key export" can now generate a printable HTML page with both a QR code and
-  a human-readable "paperkey" representation (and custom text) through the
-  ``--qr-html`` option.
-
-  The same functionality is also available through `paperkey.html <paperkey.html>`_,
-  which is the same HTML page generated by ``--qr-html``. It works with existing
-  "key export" files and key files.
-
-Other changes:
-
-- docs:
-
-  - language clarification - "borg create --one-file-system" option does not respect
-    mount points, but considers different file systems instead, #2141
-- setup.py: build_api: sort file list for determinism
-
-
-Version 1.0.10rc1 (2017-01-29)
-------------------------------
-
-Bug fixes:
-
-- borg serve: fix transmission data loss of pipe writes, #1268
-  This affects only the cygwin platform (not Linux, BSD, OS X).
-- Avoid triggering an ObjectiveFS bug in xattr retrieval, #1992
-- When running out of buffer memory when reading xattrs, only skip the
-  current file, #1993
-- Fixed "borg upgrade --tam" crashing with unencrypted repositories. Since
-  :ref:`the issue <tam_vuln>` is not relevant for unencrypted repositories,
-  it now does nothing and prints an error, #1981.
-- Fixed change-passphrase crashing with unencrypted repositories, #1978
-- Fixed "borg check repo::archive" indicating success if "archive" does not exist, #1997
-- borg check: print non-exit-code warning if --last or --prefix aren't fulfilled
-- fix bad parsing of wrong repo location syntax
-- create: don't create hard link refs to failed files,
-  mount: handle invalid hard link refs, #2092
-- detect mingw byte order, #2073
-- creating a new segment: use "xb" mode, #2099
-- mount: umount on SIGINT/^C when in foreground, #2082
-
-Other changes:
-
-- binary: use fixed AND freshly compiled pyinstaller bootloader, #2002
-- xattr: ignore empty names returned by llistxattr(2) et al
-- Enable the fault handler: install handlers for the SIGSEGV, SIGFPE, SIGABRT,
-  SIGBUS and SIGILL signals to dump the Python traceback.
-- Also print a traceback on SIGUSR2.
-- borg change-passphrase: print key location (simplify making a backup of it)
-- officially support Python 3.6 (setup.py: add Python 3.6 qualifier)
-- tests:
-
-  - vagrant / travis / tox: add Python 3.6 based testing
-  - vagrant: fix openbsd repo, #2042
-  - vagrant: fix the freebsd64 machine, #2037 #2067
-  - vagrant: use python 3.5.3 to build binaries, #2078
-  - vagrant: use osxfuse 3.5.4 for tests / to build binaries
-    vagrant: improve darwin64 VM settings
-  - travis: fix osxfuse install (fixes OS X testing on Travis CI)
-  - travis: require succeeding OS X tests, #2028
-  - travis: use latest pythons for OS X based testing
-  - use pytest-xdist to parallelize testing
-  - fix xattr test race condition, #2047
-  - setup.cfg: fix pytest deprecation warning, #2050
-- docs:
-
-  - language clarification - VM backup FAQ
-  - borg create: document how to backup stdin, #2013
-  - borg upgrade: fix incorrect title levels
-  - add CVE numbers for issues fixed in 1.0.9, #2106
-- fix typos (taken from Debian package patch)
-- remote: include data hexdump in "unexpected RPC data" error message
-- remote: log SSH command line at debug level
-- API_VERSION: use numberspaces, #2023
-- remove .github from pypi package, #2051
-- add pip and setuptools to requirements file, #2030
-- SyncFile: fix use of fd object after close (cosmetic)
-- Manifest.in: simplify, exclude \*.{so,dll,orig}, #2066
-- ignore posix_fadvise errors in repository.py, #2095
-  (works around issues with docker on ARM)
-- make LoggedIO.close_segment reentrant, avoid reentrance
-
-
-Version 1.0.9 (2016-12-20)
---------------------------
-
-Security fixes:
-
-- A flaw in the cryptographic authentication scheme in Borg allowed an attacker
-  to spoof the manifest. See :ref:`tam_vuln` above for the steps you should
-  take.
-
-  CVE-2016-10099 was assigned to this vulnerability.
-- borg check: When rebuilding the manifest (which should only be needed very rarely)
-  duplicate archive names would be handled on a "first come first serve" basis, allowing
-  an attacker to apparently replace archives.
-
-  CVE-2016-10100 was assigned to this vulnerability.
-
-Bug fixes:
-
-- borg check:
-
-  - rebuild manifest if it's corrupted
-  - skip corrupted chunks during manifest rebuild
-- fix TypeError in integrity error handler, #1903, #1894
-- fix location parser for archives with @ char (regression introduced in 1.0.8), #1930
-- fix wrong duration/timestamps if system clock jumped during a create
-- fix progress display not updating if system clock jumps backwards
-- fix checkpoint interval being incorrect if system clock jumps
-
-Other changes:
-
-- docs:
-
-  - add python3-devel as a dependency for cygwin-based installation
-  - clarify extract is relative to current directory
-  - FAQ: fix link to changelog
-  - markup fixes
-- tests:
-
-  - test_get\_(cache|keys)_dir: clean env state, #1897
-  - get back pytest's pretty assertion failures, #1938
-- setup.py build_usage:
-
-  - fixed build_usage not processing all commands
-  - fixed build_usage not generating includes for debug commands
-
-
-Version 1.0.9rc1 (2016-11-27)
------------------------------
-
-Bug fixes:
-
-- files cache: fix determination of newest mtime in backup set (which is
-  used in cache cleanup and led to wrong "A" [added] status for unchanged
-  files in next backup), #1860.
-
-- borg check:
-
-  - fix incorrectly reporting attic 0.13 and earlier archives as corrupt
-  - handle repo w/o objects gracefully and also bail out early if repo is
-    *completely* empty, #1815.
-- fix tox/pybuild in 1.0-maint
-- at xattr module import time, loggers are not initialized yet
-
-New features:
-
-- borg umount <mountpoint>
-  exposed already existing umount code via the CLI api, so users can use it,
-  which is more consistent than using borg to mount and fusermount -u (or
-  umount) to un-mount, #1855.
-- implement borg create --noatime --noctime, fixes #1853
-
-Other changes:
-
-- docs:
-
-  - display README correctly on PyPI
-  - improve cache / index docs, esp. files cache docs, fixes #1825
-  - different pattern matching for --exclude, #1779
-  - datetime formatting examples for {now} placeholder, #1822
-  - clarify passphrase mode attic repo upgrade, #1854
-  - clarify --umask usage, #1859
-  - clarify how to choose PR target branch
-  - clarify prune behavior for different archive contents, #1824
-  - fix PDF issues, add logo, fix authors, headings, TOC
-  - move security verification to support section
-  - fix links in standalone README (:ref: tags)
-  - add link to security contact in README
-  - add FAQ about security
-  - move fork differences to FAQ
-  - add more details about resource usage
-- tests: skip remote tests on cygwin, #1268
-- travis:
-
-  - allow OS X failures until the brew cask osxfuse issue is fixed
-  - caskroom osxfuse-beta gone, it's osxfuse now (3.5.3)
-- vagrant:
-
-  - upgrade OSXfuse / FUSE for macOS to 3.5.3
-  - remove llfuse from tox.ini at a central place
-  - do not try to install llfuse on centos6
-  - fix FUSE test for darwin, #1546
-  - add windows virtual machine with cygwin
-  - Vagrantfile cleanup / code deduplication
-
-
-Version 1.0.8 (2016-10-29)
---------------------------
-
-Bug fixes:
-
-- RemoteRepository: Fix busy wait in call_many, #940
-
-New features:
-
-- implement borgmajor/borgminor/borgpatch placeholders, #1694
-  {borgversion} was already there (full version string). With the new
-  placeholders you can now also get e.g. 1 or 1.0 or 1.0.8.
-
-Other changes:
-
-- avoid previous_location mismatch, #1741
-
-  due to the changed canonicalization for relative paths in PR #1711 / #1655
-  (implement /./ relpath hack), there would be a changed repo location warning
-  and the user would be asked if this is ok. this would break automation and
-  require manual intervention, which is unwanted.
-
-  thus, we automatically fix the previous_location config entry, if it only
-  changed in the expected way, but still means the same location.
-
-- docs:
-
-  - deployment.rst: do not use bare variables in ansible snippet
-  - add clarification about append-only mode, #1689
-  - setup.py: add comment about requiring llfuse, #1726
-  - update usage.rst / api.rst
-  - repo url / archive location docs + typo fix
-  - quickstart: add a comment about other (remote) filesystems
-
-- vagrant / tests:
-
-  - no chown when rsyncing (fixes boxes w/o vagrant group)
-  - fix FUSE permission issues on linux/freebsd, #1544
-  - skip FUSE test for borg binary + fakeroot
-  - ignore security.selinux xattrs, fixes tests on centos, #1735
-
-
-Version 1.0.8rc1 (2016-10-17)
------------------------------
-
-Bug fixes:
-
-- fix signal handling (SIGINT, SIGTERM, SIGHUP), #1620 #1593
-  Fixes e.g. leftover lock files for quickly repeated signals (e.g. Ctrl-C
-  Ctrl-C) or lost connections or systemd sending SIGHUP.
-- progress display: adapt formatting to narrow screens, do not crash, #1628
-- borg create --read-special - fix crash on broken symlink, #1584.
-  also correctly processes broken symlinks. before this regressed to a crash
-  (5b45385) a broken symlink would've been skipped.
-- process_symlink: fix missing backup_io()
-  Fixes a chmod/chown/chgrp/unlink/rename/... crash race between getting
-  dirents and dispatching to process_symlink.
-- yes(): abort on wrong answers, saying so, #1622
-- fixed exception borg serve raised when connection was closed before repository
-  was opened. Add an error message for this.
-- fix read-from-closed-FD issue, #1551
-  (this seems not to get triggered in 1.0.x, but was discovered in master)
-- hashindex: fix iterators (always raise StopIteration when exhausted)
-  (this seems not to get triggered in 1.0.x, but was discovered in master)
-- enable relative paths in ssh:// repo URLs, via /./relpath hack, #1655
-- allow repo paths with colons, #1705
-- update changed repo location immediately after acceptance, #1524
-- fix debug get-obj / delete-obj crash if object not found and remote repo,
-  #1684
-- pyinstaller: use a spec file to build borg.exe binary, exclude osxfuse dylib
-  on Mac OS X (avoids mismatch lib <-> driver), #1619
-
-New features:
-
-- add "borg key export" / "borg key import" commands, #1555, so users are able
-  to backup / restore their encryption keys more easily.
-
-  Supported formats are the keyfile format used by borg internally and a
-  special "paper" format with by line checksums for printed backups. For the
-  paper format, the import is an interactive process which checks each line as
-  soon as it is input.
-- add "borg debug-refcount-obj" to determine a repo objects' referrer counts,
-  #1352
-
-Other changes:
-
-- add "borg debug ..." subcommands
-  (borg debug-* still works, but will be removed in borg 1.1)
-- setup.py: Add subcommand support to build_usage.
-- remote: change exception message for unexpected RPC data format to indicate
-  dataflow direction.
-- improved messages / error reporting:
-
-  - IntegrityError: add placeholder for message, so that the message we give
-    appears not only in the traceback, but also in the (short) error message,
-    #1572
-  - borg.key: include chunk id in exception msgs, #1571
-  - better messages for cache newer than repo, #1700
-- vagrant (testing/build VMs):
-
-  - upgrade OSXfuse / FUSE for macOS to 3.5.2
-  - update Debian Wheezy boxes, #1686
-  - openbsd / netbsd: use own boxes, fixes misc rsync installation and
-    FUSE/llfuse related testing issues, #1695 #1696 #1670 #1671 #1728
-- docs:
-
-  - add docs for "key export" and "key import" commands, #1641
-  - fix inconsistency in FAQ (pv-wrapper).
-  - fix second block in "Easy to use" section not showing on GitHub, #1576
-  - add bestpractices badge
-  - link reference docs and faq about BORG_FILES_CACHE_TTL, #1561
-  - improve borg info --help, explain size infos, #1532
-  - add release signing key / security contact to README, #1560
-  - add contribution guidelines for developers
-  - development.rst: add sphinx_rtd_theme to the sphinx install command
-  - adjust border color in borg.css
-  - add debug-info usage help file
-  - internals.rst: fix typos
-  - setup.py: fix build_usage to always process all commands
-  - added docs explaining multiple --restrict-to-path flags, #1602
-  - add more specific warning about write-access debug commands, #1587
-  - clarify FAQ regarding backup of virtual machines, #1672
-- tests:
-
-  - work around FUSE xattr test issue with recent fakeroot
-  - simplify repo/hashindex tests
-  - travis: test FUSE-enabled borg, use trusty to have a recent FUSE
-  - re-enable FUSE tests for RemoteArchiver (no deadlocks any more)
-  - clean env for pytest based tests, #1714
-  - fuse_mount contextmanager: accept any options
-
-
-Version 1.0.7 (2016-08-19)
---------------------------
-
-Security fixes:
-
-- borg serve: fix security issue with remote repository access, #1428
-  If you used e.g. --restrict-to-path /path/client1/ (with or without trailing
-  slash does not make a difference), it acted like a path prefix match using
-  /path/client1 (note the missing trailing slash) - the code then also allowed
-  working in e.g. /path/client13 or /path/client1000.
-
-  As this could accidentally lead to major security/privacy issues depending on
-  the paths you use, the behaviour was changed to be a strict directory match.
-  That means --restrict-to-path /path/client1 (with or without trailing slash
-  does not make a difference) now uses /path/client1/ internally (note the
-  trailing slash here!) for matching and allows precisely that path AND any
-  path below it. So, /path/client1 is allowed, /path/client1/repo1 is allowed,
-  but not /path/client13 or /path/client1000.
-
-  If you willingly used the undocumented (dangerous) previous behaviour, you
-  may need to rearrange your --restrict-to-path paths now. We are sorry if
-  that causes work for you, but we did not want a potentially dangerous
-  behaviour in the software (not even using a for-backwards-compat option).
-
-Bug fixes:
-
-- fixed repeated LockTimeout exceptions when borg serve tried to write into
-  a already write-locked repo (e.g. by a borg mount), #502 part b)
-  This was solved by the fix for #1220 in 1.0.7rc1 already.
-- fix cosmetics + file leftover for "not a valid borg repository", #1490
-- Cache: release lock if cache is invalid, #1501
-- borg extract --strip-components: fix leak of preloaded chunk contents
-- Repository, when a InvalidRepository exception happens:
-
-  - fix spurious, empty lock.roster
-  - fix repo not closed cleanly
-
-New features:
-
-- implement borg debug-info, fixes #1122
-  (just calls already existing code via cli, same output as below tracebacks)
-
-Other changes:
-
-- skip the O_NOATIME test on GNU Hurd, fixes #1315
-  (this is a very minor issue and the GNU Hurd project knows the bug)
-- document using a clean repo to test / build the release
-
-
-Version 1.0.7rc2 (2016-08-13)
------------------------------
-
-Bug fixes:
-
-- do not write objects to repository that are bigger than the allowed size,
-  borg will reject reading them, #1451.
-
-  Important: if you created archives with many millions of files or
-  directories, please verify if you can open them successfully,
-  e.g. try a "borg list REPO::ARCHIVE".
-- lz4 compression: dynamically enlarge the (de)compression buffer, the static
-  buffer was not big enough for archives with extremely many items, #1453
-- larger item metadata stream chunks, raise archive item limit by 8x, #1452
-- fix untracked segments made by moved DELETEs, #1442
-
-  Impact: Previously (metadata) segments could become untracked when deleting data,
-  these would never be cleaned up.
-- extended attributes (xattrs) related fixes:
-
-  - fixed a race condition in xattrs querying that led to the entire file not
-    being backed up (while logging the error, exit code = 1), #1469
-  - fixed a race condition in xattrs querying that led to a crash, #1462
-  - raise OSError including the error message derived from errno, deal with
-    path being a integer FD
-
-Other changes:
-
-- print active env var override by default, #1467
-- xattr module: refactor code, deduplicate, clean up
-- repository: split object size check into too small and too big
-- add a transaction_id assertion, so borg init on a broken (inconsistent)
-  filesystem does not look like a coding error in borg, but points to the
-  real problem.
-- explain confusing TypeError caused by compat support for old servers, #1456
-- add forgotten usage help file from build_usage
-- refactor/unify buffer code into helpers.Buffer class, add tests
-- docs:
-
-  - document archive limitation, #1452
-  - improve prune examples
-
-
-Version 1.0.7rc1 (2016-08-05)
------------------------------
-
-Bug fixes:
-
-- fix repo lock deadlocks (related to lock upgrade), #1220
-- catch unpacker exceptions, resync, #1351
-- fix borg break-lock ignoring BORG_REPO env var, #1324
-- files cache performance fixes (fixes unnecessary re-reading/chunking/
-  hashing of unmodified files for some use cases):
-
-  - fix unintended file cache eviction, #1430
-  - implement BORG_FILES_CACHE_TTL, update FAQ, raise default TTL from 10
-    to 20, #1338
-- FUSE:
-
-  - cache partially read data chunks (performance), #965, #966
-  - always create a root dir, #1125
-- use an OrderedDict for helptext, making the build reproducible, #1346
-- RemoteRepository init: always call close on exceptions, #1370 (cosmetic)
-- ignore stdout/stderr broken pipe errors (cosmetic), #1116
-
-New features:
-
-- better borg versions management support (useful esp. for borg servers
-  wanting to offer multiple borg versions and for clients wanting to choose
-  a specific server borg version), #1392:
-
-  - add BORG_VERSION environment variable before executing "borg serve" via ssh
-  - add new placeholder {borgversion}
-  - substitute placeholders in --remote-path
-
-- borg init --append-only option (makes using the more secure append-only mode
-  more convenient. when used remotely, this requires 1.0.7+ also on the borg
-  server), #1291.
-
-Other changes:
-
-- Vagrantfile:
-
-  - darwin64: upgrade to FUSE for macOS 3.4.1 (aka osxfuse), #1378
-  - xenial64: use user "ubuntu", not "vagrant" (as usual), #1331
-- tests:
-
-  - fix FUSE tests on OS X, #1433
-- docs:
-
-  - FAQ: add backup using stable filesystem names recommendation
-  - FAQ about glibc compatibility added, #491, glibc-check improved
-  - FAQ: 'A' unchanged file; remove ambiguous entry age sentence.
-  - OS X: install pkg-config to build with FUSE support, fixes #1400
-  - add notes about shell/sudo pitfalls with env. vars, #1380
-  - added platform feature matrix
-- implement borg debug-dump-repo-objs
-
-
-Version 1.0.6 (2016-07-12)
---------------------------
-
-Bug fixes:
-
-- Linux: handle multiple LD_PRELOAD entries correctly, #1314, #1111
-- Fix crash with unclear message if the libc is not found, #1314, #1111
-
-Other changes:
-
-- tests:
-
-  - Fixed O_NOATIME tests for Solaris and GNU Hurd, #1315
-  - Fixed sparse file tests for (file) systems not supporting it, #1310
-- docs:
-
-  - Fixed syntax highlighting, #1313
-  - misc docs: added data processing overview picture
-
-
-Version 1.0.6rc1 (2016-07-10)
------------------------------
-
-New features:
-
-- borg check --repair: heal damaged files if missing chunks re-appear (e.g. if
-  the previously missing chunk was added again in a later backup archive),
-  #148. (*) Also improved logging.
-
-Bug fixes:
-
-- sync_dir: silence fsync() failing with EINVAL, #1287
-  Some network filesystems (like smbfs) don't support this and we use this in
-  repository code.
-- borg mount (FUSE):
-
-  - fix directories being shadowed when contained paths were also specified,
-    #1295
-  - raise I/O Error (EIO) on damaged files (unless -o allow_damaged_files is
-    used), #1302. (*)
-- borg extract: warn if a damaged file is extracted, #1299. (*)
-- Added some missing return code checks (ChunkIndex._add, hashindex_resize).
-- borg check: fix/optimize initial hash table size, avoids resize of the table.
-
-Other changes:
-
-- tests:
-
-  - add more FUSE tests, #1284
-  - deduplicate FUSE (u)mount code
-  - fix borg binary test issues, #862
-- docs:
-
-  - changelog: added release dates to older borg releases
-  - fix some sphinx (docs generator) warnings, #881
-
-Notes:
-
-(*) Some features depend on information (chunks_healthy list) added to item
-metadata when a file with missing chunks was "repaired" using all-zero
-replacement chunks. The chunks_healthy list is generated since borg 1.0.4,
-thus borg can't recognize such "repaired" (but content-damaged) files if the
-repair was done with an older borg version.
-
-
-Version 1.0.5 (2016-07-07)
---------------------------
-
-Bug fixes:
-
-- borg mount: fix FUSE crash in xattr code on Linux introduced in 1.0.4, #1282
-
-Other changes:
-
-- backport some FAQ entries from master branch
-- add release helper scripts
-- Vagrantfile:
-
-  - centos6: no FUSE, don't build binary
-  - add xz for redhat-like dists
-
-
-Version 1.0.4 (2016-07-07)
---------------------------
-
-New features:
-
-- borg serve --append-only, #1168
-  This was included because it was a simple change (append-only functionality
-  was already present via repository config file) and makes better security now
-  practically usable.
-- BORG_REMOTE_PATH environment variable, #1258
-  This was included because it was a simple change (--remote-path cli option
-  was already present) and makes borg much easier to use if you need it.
-- Repository: cleanup incomplete transaction on "no space left" condition.
-  In many cases, this can avoid a 100% full repo filesystem (which is very
-  problematic as borg always needs free space - even to delete archives).
-
-Bug fixes:
-
-- Fix wrong handling and reporting of OSErrors in borg create, #1138.
-  This was a serious issue: in the context of "borg create", errors like
-  repository I/O errors (e.g. disk I/O errors, ssh repo connection errors)
-  were handled badly and did not lead to a crash (which would be good for this
-  case, because the repo transaction would be incomplete and trigger a
-  transaction rollback to clean up).
-  Now, error handling for source files is cleanly separated from every other
-  error handling, so only problematic input files are logged and skipped.
-- Implement fail-safe error handling for borg extract.
-  Note that this isn't nearly as critical as the borg create error handling
-  bug, since nothing is written to the repo. So this was "merely" misleading
-  error reporting.
-- Add missing error handler in directory attr restore loop.
-- repo: make sure write data hits disk before the commit tag (#1236) and also
-  sync the containing directory.
-- FUSE: getxattr fail must use errno.ENOATTR, #1126
-  (fixes Mac OS X Finder malfunction: "zero bytes" file length, access denied)
-- borg check --repair: do not lose information about the good/original chunks.
-  If we do not lose the original chunk IDs list when "repairing" a file
-  (replacing missing chunks with all-zero chunks), we have a chance to "heal"
-  the file back into its original state later, in case the chunks re-appear
-  (e.g. in a fresh backup). Healing is not implemented yet, see #148.
-- fixes for --read-special mode:
-
-  - ignore known files cache, #1241
-  - fake regular file mode, #1214
-  - improve symlinks handling, #1215
-- remove passphrase from subprocess environment, #1105
-- Ignore empty index file (will trigger index rebuild), #1195
-- add missing placeholder support for --prefix, #1027
-- improve exception handling for placeholder replacement
-- catch and format exceptions in arg parsing
-- helpers: fix "undefined name 'e'" in exception handler
-- better error handling for missing repo manifest, #1043
-- borg delete:
-
-  - make it possible to delete a repo without manifest
-  - borg delete --forced allows one to delete corrupted archives, #1139
-- borg check:
-
-  - make borg check work for empty repo
-  - fix resync and msgpacked item qualifier, #1135
-  - rebuild_manifest: fix crash if 'name' or 'time' key were missing.
-  - better validation of item metadata dicts, #1130
-  - better validation of archive metadata dicts
-- close the repo on exit - even if rollback did not work, #1197.
-  This is rather cosmetic, it avoids repo closing in the destructor.
-
-- tests:
-
-  - fix sparse file test, #1170
-  - flake8: ignore new F405, #1185
-  - catch "invalid argument" on cygwin, #257
-  - fix sparseness assertion in test prep, #1264
-
-Other changes:
-
-- make borg build/work on OpenSSL 1.0 and 1.1, #1187
-- docs / help:
-
-  - fix / clarify prune help, #1143
-  - fix "patterns" help formatting
-  - add missing docs / help about placeholders
-  - resources: rename atticmatic to borgmatic
-  - document sshd settings, #545
-  - more details about checkpoints, add split trick, #1171
-  - support docs: add freenode web chat link, #1175
-  - add prune visualization / example, #723
-  - add note that Fnmatch is default, #1247
-  - make clear that lzma levels > 6 are a waste of cpu cycles
-  - add a "do not edit" note to auto-generated files, #1250
-  - update cygwin installation docs
-- repository interoperability with borg master (1.1dev) branch:
-
-  - borg check: read item metadata keys from manifest, #1147
-  - read v2 hints files, #1235
-  - fix hints file "unknown version" error handling bug
-- tests: add tests for format_line
-- llfuse: update version requirement for freebsd
-- Vagrantfile:
-
-  - use openbsd 5.9, #716
-  - do not install llfuse on netbsd (broken)
-  - update OSXfuse to version 3.3.3
-  - use Python 3.5.2 to build the binaries
-- glibc compatibility checker: scripts/glibc_check.py
-- add .eggs to .gitignore
-
-
-Version 1.0.3 (2016-05-20)
---------------------------
-
-Bug fixes:
-
-- prune: avoid that checkpoints are kept and completed archives are deleted in
-  a prune run), #997
-- prune: fix commandline argument validation - some valid command lines were
-  considered invalid (annoying, but harmless), #942
-- fix capabilities extraction on Linux (set xattrs last, after chown()), #1069
-- repository: fix commit tags being seen in data
-- when probing key files, do binary reads. avoids crash when non-borg binary
-  files are located in borg's key files directory.
-- handle SIGTERM and make a clean exit - avoids orphan lock files.
-- repository cache: don't cache large objects (avoid using lots of temp. disk
-  space), #1063
-
-Other changes:
-
-- Vagrantfile: OS X: update osxfuse / install lzma package, #933
-- setup.py: add check for platform_darwin.c
-- setup.py: on freebsd, use a llfuse release that builds ok
-- docs / help:
-
-  - update readthedocs URLs, #991
-  - add missing docs for "borg break-lock", #992
-  - borg create help: add some words to about the archive name
-  - borg create help: document format tags, #894
-
-
-Version 1.0.2 (2016-04-16)
---------------------------
-
-Bug fixes:
-
-- fix malfunction and potential corruption on (nowadays rather rare) big-endian
-  architectures or bi-endian archs in (rare) BE mode. #886, #889
-
-  cache resync / index merge was malfunctioning due to this, potentially
-  leading to data loss. borg info had cosmetic issues (displayed wrong values).
-
-  note: all (widespread) little-endian archs (like x86/x64) or bi-endian archs
-  in (widespread) LE mode (like ARMEL, MIPSEL, ...) were NOT affected.
-- add overflow and range checks for 1st (special) uint32 of the hashindex
-  values, switch from int32 to uint32.
-- fix so that refcount will never overflow, but just stick to max. value after
-  a overflow would have occurred.
-- borg delete: fix --cache-only for broken caches, #874
-
-  Makes --cache-only idempotent: it won't fail if the cache is already deleted.
-- fixed borg create --one-file-system erroneously traversing into other
-  filesystems (if starting fs device number was 0), #873
-- workaround a bug in Linux fadvise FADV_DONTNEED, #907
-
-Other changes:
-
-- better test coverage for hashindex, incl. overflow testing, checking correct
-  computations so endianness issues would be discovered.
-- reproducible doc for ProgressIndicator*,  make the build reproducible.
-- use latest llfuse for vagrant machines
-- docs:
-
-  - use /path/to/repo in examples, fixes #901
-  - fix confusing usage of "repo" as archive name (use "arch")
-
-
-Version 1.0.1 (2016-04-08)
---------------------------
-
-New features:
-
-Usually there are no new features in a bugfix release, but these were added
-due to their high impact on security/safety/speed or because they are fixes
-also:
-
-- append-only mode for repositories, #809, #36 (see docs)
-- borg create: add --ignore-inode option to make borg detect unmodified files
-  even if your filesystem does not have stable inode numbers (like sshfs and
-  possibly CIFS).
-- add options --warning, --error, --critical for missing log levels, #826.
-  it's not recommended to suppress warnings or errors, but the user may decide
-  this on his own.
-  note: --warning is not given to borg serve so a <= 1.0.0 borg will still
-  work as server (it is not needed as it is the default).
-  do not use --error or --critical when using a <= 1.0.0 borg server.
-
-Bug fixes:
-
-- fix silently skipping EIO, #748
-- add context manager for Repository (avoid orphan repository locks), #285
-- do not sleep for >60s while waiting for lock, #773
-- unpack file stats before passing to FUSE
-- fix build on illumos
-- don't try to backup doors or event ports (Solaris and derivatives)
-- remove useless/misleading libc version display, #738
-- test suite: reset exit code of persistent archiver, #844
-- RemoteRepository: clean up pipe if remote open() fails
-- Remote: don't print tracebacks for Error exceptions handled downstream, #792
-- if BORG_PASSPHRASE is present but wrong, don't prompt for password, but fail
-  instead, #791
-- ArchiveChecker: move "orphaned objects check skipped" to INFO log level, #826
-- fix capitalization, add ellipses, change log level to debug for 2 messages,
-  #798
-
-Other changes:
-
-- update llfuse requirement, llfuse 1.0 works
-- update OS / dist packages on build machines, #717
-- prefer showing --info over -v in usage help, #859
-- docs:
-
-  - fix cygwin requirements (gcc-g++)
-  - document how to debug / file filesystem issues, #664
-  - fix reproducible build of api docs
-  - RTD theme: CSS !important overwrite, #727
-  - Document logo font. Recreate logo png. Remove GIMP logo file.
-
-
-Version 1.0.0 (2016-03-05)
---------------------------
-
-The major release number change (0.x -> 1.x) indicates bigger incompatible
-changes, please read the compatibility notes, adapt / test your scripts and
-check your backup logs.
-
-Compatibility notes:
-
-- drop support for python 3.2 and 3.3, require 3.4 or 3.5, #221 #65 #490
-  note: we provide binaries that include python 3.5.1 and everything else
-  needed. they are an option in case you are stuck with < 3.4 otherwise.
-- change encryption to be on by default (using "repokey" mode)
-- moved keyfile keys from ~/.borg/keys to ~/.config/borg/keys,
-  you can either move them manually or run "borg upgrade <REPO>"
-- remove support for --encryption=passphrase,
-  use borg migrate-to-repokey to switch to repokey mode, #97
-- remove deprecated --compression <number>,
-  use --compression zlib,<number> instead
-  in case of 0, you could also use --compression none
-- remove deprecated --hourly/daily/weekly/monthly/yearly
-  use --keep-hourly/daily/weekly/monthly/yearly instead
-- remove deprecated --do-not-cross-mountpoints,
-  use --one-file-system instead
-- disambiguate -p option, #563:
-
-  - -p now is same as --progress
-  - -P now is same as --prefix
-- remove deprecated "borg verify",
-  use "borg extract --dry-run" instead
-- cleanup environment variable semantics, #355
-  the environment variables used to be "yes sayers" when set, this was
-  conceptually generalized to "automatic answerers" and they just give their
-  value as answer (as if you typed in that value when being asked).
-  See the "usage" / "Environment Variables" section of the docs for details.
-- change the builtin default for --chunker-params, create 2MiB chunks, #343
-  --chunker-params new default: 19,23,21,4095 - old default: 10,23,16,4095
-
-  one of the biggest issues with borg < 1.0 (and also attic) was that it had a
-  default target chunk size of 64kiB, thus it created a lot of chunks and thus
-  also a huge chunk management overhead (high RAM and disk usage).
-
-  please note that the new default won't change the chunks that you already
-  have in your repository. the new big chunks do not deduplicate with the old
-  small chunks, so expect your repo to grow at least by the size of every
-  changed file and in the worst case (e.g. if your files cache was lost / is
-  not used) by the size of every file (minus any compression you might use).
-
-  in case you want to immediately see a much lower resource usage (RAM / disk)
-  for chunks management, it might be better to start with a new repo than
-  continuing in the existing repo (with an existing repo, you'ld have to wait
-  until all archives with small chunks got pruned to see a lower resource
-  usage).
-
-  if you used the old --chunker-params default value (or if you did not use
-  --chunker-params option at all) and you'ld like to continue using small
-  chunks (and you accept the huge resource usage that comes with that), just
-  explicitly use borg create --chunker-params=10,23,16,4095.
-- archive timestamps: the 'time' timestamp now refers to archive creation
-  start time (was: end time), the new 'time_end' timestamp refers to archive
-  creation end time. This might affect prune if your backups take rather long.
-  if you give a timestamp via cli this is stored into 'time', therefore it now
-  needs to mean archive creation start time.
-
-New features:
-
-- implement password roundtrip, #695
-
-Bug fixes:
-
-- remote end does not need cache nor keys directories, do not create them, #701
-- added retry counter for passwords, #703
-
-Other changes:
-
-- fix compiler warnings, #697
-- docs:
-
-  - update README.rst to new changelog location in docs/changes.rst
-  - add Teemu to AUTHORS
-  - changes.rst: fix old chunker params, #698
-  - FAQ: how to limit bandwidth
-
-
-Version 1.0.0rc2 (2016-02-28)
------------------------------
-
-New features:
-
-- format options for location: user, pid, fqdn, hostname, now, utcnow, user
-- borg list --list-format
-- borg prune -v --list enables the keep/prune list output, #658
-
-Bug fixes:
-
-- fix _open_rb noatime handling, #657
-- add a simple archivename validator, #680
-- borg create --stats: show timestamps in localtime, use same labels/formatting
-  as borg info, #651
-- llfuse compatibility fixes (now compatible with: 0.40, 0.41, 0.42)
-
-Other changes:
-
-- it is now possible to use "pip install borgbackup[fuse]" to automatically
-  install the llfuse dependency using the correct version requirement
-  for it. you still need to care about having installed the FUSE / build
-  related OS package first, though, so that building llfuse can succeed.
-- Vagrant: drop Ubuntu Precise (12.04) - does not have Python >= 3.4
-- Vagrant: use pyinstaller v3.1.1 to build binaries
-- docs:
-
-  - borg upgrade: add to docs that only LOCAL repos are supported
-  - borg upgrade also handles borg 0.xx -> 1.0
-  - use pip extras or requirements file to install llfuse
-  - fix order in release process
-  - updated usage docs and other minor / cosmetic fixes
-  - verified borg examples in docs, #644
-  - freebsd dependency installation and FUSE configuration, #649
-  - add example how to restore a raw device, #671
-  - add a hint about the dev headers needed when installing from source
-  - add examples for delete (and handle delete after list, before prune), #656
-  - update example for borg create -v --stats (use iso datetime format), #663
-  - added example to BORG_RSH docs
-  - "connection closed by remote": add FAQ entry and point to issue #636
-
-
-Version 1.0.0rc1 (2016-02-07)
------------------------------
-
-New features:
-
-- borg migrate-to-repokey ("passphrase" -> "repokey" encryption key mode)
-- implement --short for borg list REPO, #611
-- implement --list for borg extract (consistency with borg create)
-- borg serve: overwrite client's --restrict-to-path with ssh forced command's
-  option value (but keep everything else from the client commandline), #544
-- use $XDG_CONFIG_HOME/keys for keyfile keys (~/.config/borg/keys), #515
-- "borg upgrade" moves the keyfile keys to the new location
-- display both archive creation start and end time in "borg info", #627
-
-
-Bug fixes:
-
-- normalize trailing slashes for the repository path, #606
-- Cache: fix exception handling in __init__, release lock, #610
-
-Other changes:
-
-- suppress unneeded exception context (PEP 409), simpler tracebacks
-- removed special code needed to deal with imperfections / incompatibilities /
-  missing stuff in py 3.2/3.3, simplify code that can be done simpler in 3.4
-- removed some version requirements that were kept on old versions because
-  newer did not support py 3.2 any more
-- use some py 3.4+ stdlib code instead of own/openssl/pypi code:
-
-  - use os.urandom instead of own cython openssl RAND_bytes wrapper, #493
-  - use hashlib.pbkdf2_hmac from py stdlib instead of own openssl wrapper
-  - use hmac.compare_digest instead of == operator (constant time comparison)
-  - use stat.filemode instead of homegrown code
-  - use "mock" library from stdlib, #145
-  - remove borg.support (with non-broken argparse copy), it is ok in 3.4+, #358
-- Vagrant: copy CHANGES.rst as symlink, #592
-- cosmetic code cleanups, add flake8 to tox/travis, #4
-- docs / help:
-
-  - make "borg -h" output prettier, #591
-  - slightly rephrase prune help
-  - add missing example for --list option of borg create
-  - quote exclude line that includes an asterisk to prevent shell expansion
-  - fix dead link to license
-  - delete Ubuntu Vivid, it is not supported anymore (EOL)
-  - OS X binary does not work for older OS X releases, #629
-  - borg serve's special support for forced/original ssh commands, #544
-  - misc. updates and fixes
-
-
-Version 0.30.0 (2016-01-23)
----------------------------
-
-Compatibility notes:
-
-- you may need to use -v (or --info) more often to actually see output emitted
-  at INFO log level (because it is suppressed at the default WARNING log level).
-  See the "general" section in the usage docs.
-- for borg create, you need --list (additionally to -v) to see the long file
-  list (was needed so you can have e.g. --stats alone without the long list)
-- see below about BORG_DELETE_I_KNOW_WHAT_I_AM_DOING (was:
-  BORG_CHECK_I_KNOW_WHAT_I_AM_DOING)
-
-Bug fixes:
-
-- fix crash when using borg create --dry-run --keep-tag-files, #570
-- make sure teardown with cleanup happens for Cache and RepositoryCache,
-  avoiding leftover locks and TEMP dir contents, #285 (partially), #548
-- fix locking KeyError, partial fix for #502
-- log stats consistently, #526
-- add abbreviated weekday to timestamp format, fixes #496
-- strip whitespace when loading exclusions from file
-- unset LD_LIBRARY_PATH before invoking ssh, fixes strange OpenSSL library
-  version warning when using the borg binary, #514
-- add some error handling/fallback for C library loading, #494
-- added BORG_DELETE_I_KNOW_WHAT_I_AM_DOING for check in "borg delete", #503
-- remove unused "repair" rpc method name
-
-New features:
-
-- borg create: implement exclusions using regular expression patterns.
-- borg create: implement inclusions using patterns.
-- borg extract: support patterns, #361
-- support different styles for patterns:
-
-  - fnmatch (`fm:` prefix, default when omitted), like borg <= 0.29.
-  - shell (`sh:` prefix) with `*` not matching directory separators and
-    `**/` matching 0..n directories
-  - path prefix (`pp:` prefix, for unifying borg create pp1 pp2 into the
-    patterns system), semantics like in borg <= 0.29
-  - regular expression (`re:`), new!
-- --progress option for borg upgrade (#291) and borg delete <archive>
-- update progress indication more often (e.g. for borg create within big
-  files or for borg check repo), #500
-- finer chunker granularity for items metadata stream, #547, #487
-- borg create --list now used (additionally to -v) to enable the verbose
-  file list output
-- display borg version below tracebacks, #532
-
-Other changes:
-
-- hashtable size (and thus: RAM and disk consumption) follows a growth policy:
-  grows fast while small, grows slower when getting bigger, #527
-- Vagrantfile: use pyinstaller 3.1 to build binaries, freebsd sqlite3 fix,
-  fixes #569
-- no separate binaries for centos6 any more because the generic linux binaries
-  also work on centos6 (or in general: on systems with a slightly older glibc
-  than debian7
-- dev environment: require virtualenv<14.0 so we get a py32 compatible pip
-- docs:
-
-  - add space-saving chunks.archive.d trick to FAQ
-  - important: clarify -v and log levels in usage -> general, please read!
-  - sphinx configuration: create a simple man page from usage docs
-  - add a repo server setup example
-  - disable unneeded SSH features in authorized_keys examples for security.
-  - borg prune only knows "--keep-within" and not "--within"
-  - add gource video to resources docs, #507
-  - add netbsd install instructions
-  - authors: make it more clear what refers to borg and what to attic
-  - document standalone binary requirements, #499
-  - rephrase the mailing list section
-  - development docs: run build_api and build_usage before tagging release
-  - internals docs: hash table max. load factor is 0.75 now
-  - markup, typo, grammar, phrasing, clarifications and other fixes.
-  - add gcc gcc-c++ to redhat/fedora/corora install docs, fixes #583
-
-
-Version 0.29.0 (2015-12-13)
----------------------------
-
-Compatibility notes:
-
-- when upgrading to 0.29.0 you need to upgrade client as well as server
-  installations due to the locking and commandline interface changes otherwise
-  you'll get an error msg about a RPC protocol mismatch or a wrong commandline
-  option.
-  if you run a server that needs to support both old and new clients, it is
-  suggested that you have a "borg-0.28.2" and a "borg-0.29.0" command.
-  clients then can choose via e.g. "borg --remote-path=borg-0.29.0 ...".
-- the default waiting time for a lock changed from infinity to 1 second for a
-  better interactive user experience. if the repo you want to access is
-  currently locked, borg will now terminate after 1s with an error message.
-  if you have scripts that shall wait for the lock for a longer time, use
-  --lock-wait N (with N being the maximum wait time in seconds).
-
-Bug fixes:
-
-- hash table tuning (better chosen hashtable load factor 0.75 and prime initial
-  size of 1031 gave ~1000x speedup in some scenarios)
-- avoid creation of an orphan lock for one case, #285
-- --keep-tag-files: fix file mode and multiple tag files in one directory, #432
-- fixes for "borg upgrade" (attic repo converter), #466
-- remove --progress isatty magic (and also --no-progress option) again, #476
-- borg init: display proper repo URL
-- fix format of umask in help pages, #463
-
-New features:
-
-- implement --lock-wait, support timeout for UpgradableLock, #210
-- implement borg break-lock command, #157
-- include system info below traceback, #324
-- sane remote logging, remote stderr, #461:
-
-  - remote log output: intercept it and log it via local logging system,
-    with "Remote: " prefixed to message. log remote tracebacks.
-  - remote stderr: output it to local stderr with "Remote: " prefixed.
-- add --debug and --info (same as --verbose) to set the log level of the
-  builtin logging configuration (which otherwise defaults to warning), #426
-  note: there are few messages emitted at DEBUG level currently.
-- optionally configure logging via env var BORG_LOGGING_CONF
-- add --filter option for status characters: e.g. to show only the added
-  or modified files (and also errors), use "borg create -v --filter=AME ...".
-- more progress indicators, #394
-- use ISO-8601 date and time format, #375
-- "borg check --prefix" to restrict archive checking to that name prefix, #206
-
-Other changes:
-
-- hashindex_add C implementation (speed up cache re-sync for new archives)
-- increase FUSE read_size to 1024 (speed up metadata operations)
-- check/delete/prune --save-space: free unused segments quickly, #239
-- increase rpc protocol version to 2 (see also Compatibility notes), #458
-- silence borg by default (via default log level WARNING)
-- get rid of C compiler warnings, #391
-- upgrade OS X FUSE to 3.0.9 on the OS X binary build system
-- use python 3.5.1 to build binaries
-- docs:
-
-  - new mailing list borgbackup@python.org, #468
-  - readthedocs: color and logo improvements
-  - load coverage icons over SSL (avoids mixed content)
-  - more precise binary installation steps
-  - update release procedure docs about OS X FUSE
-  - FAQ entry about unexpected 'A' status for unchanged file(s), #403
-  - add docs about 'E' file status
-  - add "borg upgrade" docs, #464
-  - add developer docs about output and logging
-  - clarify encryption, add note about client-side encryption
-  - add resources section, with videos, talks, presentations, #149
-  - Borg moved to Arch Linux [community]
-  - fix wrong installation instructions for archlinux
-
-
-Version 0.28.2 (2015-11-15)
----------------------------
-
-New features:
-
-- borg create --exclude-if-present TAGFILE - exclude directories that have the
-  given file from the backup. You can additionally give --keep-tag-files to
-  preserve just the directory roots and the tag-files (but not backup other
-  directory contents), #395, attic #128, attic #142
-
-Other changes:
-
-- do not create docs sources at build time (just have them in the repo),
-  completely remove have_cython() hack, do not use the "mock" library at build
-  time, #384
-- avoid hidden import, make it easier for PyInstaller, easier fix for #218
-- docs:
-
-  - add description of item flags / status output, fixes #402
-  - explain how to regenerate usage and API files (build_api or
-    build_usage) and when to commit usage files directly into git, #384
-  - minor install docs improvements
-
-
-Version 0.28.1 (2015-11-08)
----------------------------
-
-Bug fixes:
-
-- do not try to build api / usage docs for production install,
-  fixes unexpected "mock" build dependency, #384
-
-Other changes:
-
-- avoid using msgpack.packb at import time
-- fix formatting issue in changes.rst
-- fix build on readthedocs
-
-
-Version 0.28.0 (2015-11-08)
----------------------------
-
-Compatibility notes:
-
-- changed return codes (exit codes), see docs. in short:
-  old: 0 = ok, 1 = error. now: 0 = ok, 1 = warning, 2 = error
-
-New features:
-
-- refactor return codes (exit codes), fixes #61
-- add --show-rc option enable "terminating with X status, rc N" output, fixes 58, #351
-- borg create backups atime and ctime additionally to mtime, fixes #317
-  - extract: support atime additionally to mtime
-  - FUSE: support ctime and atime additionally to mtime
-- support borg --version
-- emit a warning if we have a slow msgpack installed
-- borg list --prefix=thishostname- REPO, fixes #205
-- Debug commands (do not use except if you know what you do: debug-get-obj,
-  debug-put-obj, debug-delete-obj, debug-dump-archive-items.
-
-Bug fixes:
-
-- setup.py: fix bug related to BORG_LZ4_PREFIX processing
-- fix "check" for repos that have incomplete chunks, fixes #364
-- borg mount: fix unlocking of repository at umount time, fixes #331
-- fix reading files without touching their atime, #334
-- non-ascii ACL fixes for Linux, FreeBSD and OS X, #277
-- fix acl_use_local_uid_gid() and add a test for it, attic #359
-- borg upgrade: do not upgrade repositories in place by default, #299
-- fix cascading failure with the index conversion code, #269
-- borg check: implement 'cmdline' archive metadata value decoding, #311
-- fix RobustUnpacker, it missed some metadata keys (new atime and ctime keys
-  were missing, but also bsdflags). add check for unknown metadata keys.
-- create from stdin: also save atime, ctime (cosmetic)
-- use default_notty=False for confirmations, fixes #345
-- vagrant: fix msgpack installation on centos, fixes #342
-- deal with unicode errors for symlinks in same way as for regular files and
-  have a helpful warning message about how to fix wrong locale setup, fixes #382
-- add ACL keys the RobustUnpacker must know about
-
-Other changes:
-
-- improve file size displays, more flexible size formatters
-- explicitly commit to the units standard, #289
-- archiver: add E status (means that an error occurred when processing this
-  (single) item
-- do binary releases via "github releases", closes #214
-- create: use -x and --one-file-system (was: --do-not-cross-mountpoints), #296
-- a lot of changes related to using "logging" module and screen output, #233
-- show progress display if on a tty, output more progress information, #303
-- factor out status output so it is consistent, fix surrogates removal,
-  maybe fixes #309
-- move away from RawConfigParser to ConfigParser
-- archive checker: better error logging, give chunk_id and sequence numbers
-  (can be used together with borg debug-dump-archive-items).
-- do not mention the deprecated passphrase mode
-- emit a deprecation warning for --compression N (giving a just a number)
-- misc .coverragerc fixes (and coverage measurement improvements), fixes #319
-- refactor confirmation code, reduce code duplication, add tests
-- prettier error messages, fixes #307, #57
-- tests:
-
-  - add a test to find disk-full issues, #327
-  - travis: also run tests on Python 3.5
-  - travis: use tox -r so it rebuilds the tox environments
-  - test the generated pyinstaller-based binary by archiver unit tests, #215
-  - vagrant: tests: announce whether fakeroot is used or not
-  - vagrant: add vagrant user to fuse group for debianoid systems also
-  - vagrant: llfuse install on darwin needs pkgconfig installed
-  - vagrant: use pyinstaller from develop branch, fixes #336
-  - benchmarks: test create, extract, list, delete, info, check, help, fixes #146
-  - benchmarks: test with both the binary and the python code
-  - archiver tests: test with both the binary and the python code, fixes #215
-  - make basic test more robust
-- docs:
-
-  - moved docs to borgbackup.readthedocs.org, #155
-  - a lot of fixes and improvements, use mobile-friendly RTD standard theme
-  - use zlib,6 compression in some examples, fixes #275
-  - add missing rename usage to docs, closes #279
-  - include the help offered by borg help <topic> in the usage docs, fixes #293
-  - include a list of major changes compared to attic into README, fixes #224
-  - add OS X install instructions, #197
-  - more details about the release process, #260
-  - fix linux glibc requirement (binaries built on debian7 now)
-  - build: move usage and API generation to setup.py
-  - update docs about return codes, #61
-  - remove api docs (too much breakage on rtd)
-  - borgbackup install + basics presentation (asciinema)
-  - describe the current style guide in documentation
-  - add section about debug commands
-  - warn about not running out of space
-  - add example for rename
-  - improve chunker params docs, fixes #362
-  - minor development docs update
-
-
-Version 0.27.0 (2015-10-07)
----------------------------
-
-New features:
-
-- "borg upgrade" command - attic -> borg one time converter / migration, #21
-- temporary hack to avoid using lots of disk space for chunks.archive.d, #235:
-  To use it: rm -rf chunks.archive.d ; touch chunks.archive.d
-- respect XDG_CACHE_HOME, attic #181
-- add support for arbitrary SSH commands, attic #99
-- borg delete --cache-only REPO (only delete cache, not REPO), attic #123
-
-
-Bug fixes:
-
-- use Debian 7 (wheezy) to build pyinstaller borgbackup binaries, fixes slow
-  down observed when running the Centos6-built binary on Ubuntu, #222
-- do not crash on empty lock.roster, fixes #232
-- fix multiple issues with the cache config version check, #234
-- fix segment entry header size check, attic #352
-  plus other error handling improvements / code deduplication there.
-- always give segment and offset in repo IntegrityErrors
-
-
-Other changes:
-
-- stop producing binary wheels, remove docs about it, #147
-- docs:
-  - add warning about prune
-  - generate usage include files only as needed
-  - development docs: add Vagrant section
-  - update / improve / reformat FAQ
-  - hint to single-file pyinstaller binaries from README
-
-
-Version 0.26.1 (2015-09-28)
----------------------------
-
-This is a minor update, just docs and new pyinstaller binaries.
-
-- docs update about python and binary requirements
-- better docs for --read-special, fix #220
-- re-built the binaries, fix #218 and #213 (glibc version issue)
-- update web site about single-file pyinstaller binaries
-
-Note: if you did a python-based installation, there is no need to upgrade.
-
-
-Version 0.26.0 (2015-09-19)
----------------------------
-
-New features:
-
-- Faster cache sync (do all in one pass, remove tar/compression stuff), #163
-- BORG_REPO env var to specify the default repo, #168
-- read special files as if they were regular files, #79
-- implement borg create --dry-run, attic issue #267
-- Normalize paths before pattern matching on OS X, #143
-- support OpenBSD and NetBSD (except xattrs/ACLs)
-- support / run tests on Python 3.5
-
-Bug fixes:
-
-- borg mount repo: use absolute path, attic #200, attic #137
-- chunker: use off_t to get 64bit on 32bit platform, #178
-- initialize chunker fd to -1, so it's not equal to STDIN_FILENO (0)
-- fix reaction to "no" answer at delete repo prompt, #182
-- setup.py: detect lz4.h header file location
-- to support python < 3.2.4, add less buggy argparse lib from 3.2.6 (#194)
-- fix for obtaining ``char *`` from temporary Python value (old code causes
-  a compile error on Mint 17.2)
-- llfuse 0.41 install troubles on some platforms, require < 0.41
-  (UnicodeDecodeError exception due to non-ascii llfuse setup.py)
-- cython code: add some int types to get rid of unspecific python add /
-  subtract operations (avoid ``undefined symbol FPE_``... error on some platforms)
-- fix verbose mode display of stdin backup
-- extract: warn if a include pattern never matched, fixes #209,
-  implement counters for Include/ExcludePatterns
-- archive names with slashes are invalid, attic issue #180
-- chunker: add a check whether the POSIX_FADV_DONTNEED constant is defined -
-  fixes building on OpenBSD.
-
-Other changes:
-
-- detect inconsistency / corruption / hash collision, #170
-- replace versioneer with setuptools_scm, #106
-- docs:
-
-  - pkg-config is needed for llfuse installation
-  - be more clear about pruning, attic issue #132
-- unit tests:
-
-  - xattr: ignore security.selinux attribute showing up
-  - ext3 seems to need a bit more space for a sparse file
-  - do not test lzma level 9 compression (avoid MemoryError)
-  - work around strange mtime granularity issue on netbsd, fixes #204
-  - ignore st_rdev if file is not a block/char device, fixes #203
-  - stay away from the setgid and sticky mode bits
-- use Vagrant to do easy cross-platform testing (#196), currently:
-
-  - Debian 7 "wheezy" 32bit, Debian 8 "jessie" 64bit
-  - Ubuntu 12.04 32bit, Ubuntu 14.04 64bit
-  - Centos 7 64bit
-  - FreeBSD 10.2 64bit
-  - OpenBSD 5.7 64bit
-  - NetBSD 6.1.5 64bit
-  - Darwin (OS X Yosemite)
-
-
-Version 0.25.0 (2015-08-29)
----------------------------
-
-Compatibility notes:
-
-- lz4 compression library (liblz4) is a new requirement (#156)
-- the new compression code is very compatible: as long as you stay with zlib
-  compression, older borg releases will still be able to read data from a
-  repo/archive made with the new code (note: this is not the case for the
-  default "none" compression, use "zlib,0" if you want a "no compression" mode
-  that can be read by older borg). Also the new code is able to read repos and
-  archives made with older borg versions (for all zlib levels  0..9).
-
-Deprecations:
-
-- --compression N (with N being a number, as in 0.24) is deprecated.
-  We keep the --compression 0..9 for now to not break scripts, but it is
-  deprecated and will be removed later, so better fix your scripts now:
-  --compression 0 (as in 0.24) is the same as --compression zlib,0 (now).
-  BUT: if you do not want compression, you rather want --compression none
-  (which is the default).
-  --compression 1 (in 0.24) is the same as --compression zlib,1 (now)
-  --compression 9 (in 0.24) is the same as --compression zlib,9 (now)
-
-New features:
-
-- create --compression none (default, means: do not compress, just pass through
-  data "as is". this is more efficient than zlib level 0 as used in borg 0.24)
-- create --compression lz4 (super-fast, but not very high compression)
-- create --compression zlib,N (slower, higher compression, default for N is 6)
-- create --compression lzma,N (slowest, highest compression, default N is 6)
-- honor the nodump flag (UF_NODUMP) and do not backup such items
-- list --short just outputs a simple list of the files/directories in an archive
-
-Bug fixes:
-
-- fixed --chunker-params parameter order confusion / malfunction, fixes #154
-- close fds of segments we delete (during compaction)
-- close files which fell out the lrucache
-- fadvise DONTNEED now is only called for the byte range actually read, not for
-  the whole file, fixes #158.
-- fix issue with negative "all archives" size, fixes #165
-- restore_xattrs: ignore if setxattr fails with EACCES, fixes #162
-
-Other changes:
-
-- remove fakeroot requirement for tests, tests run faster without fakeroot
-  (test setup does not fail any more without fakeroot, so you can run with or
-  without fakeroot), fixes #151 and #91.
-- more tests for archiver
-- recover_segment(): don't assume we have an fd for segment
-- lrucache refactoring / cleanup, add dispose function, py.test tests
-- generalize hashindex code for any key length (less hardcoding)
-- lock roster: catch file not found in remove() method and ignore it
-- travis CI: use requirements file
-- improved docs:
-
-  - replace hack for llfuse with proper solution (install libfuse-dev)
-  - update docs about compression
-  - update development docs about fakeroot
-  - internals: add some words about lock files / locking system
-  - support: mention BountySource and for what it can be used
-  - theme: use a lighter green
-  - add pypi, wheel, dist package based install docs
-  - split install docs into system-specific preparations and generic instructions
-
-
-Version 0.24.0 (2015-08-09)
----------------------------
-
-Incompatible changes (compared to 0.23):
-
-- borg now always issues --umask NNN option when invoking another borg via ssh
-  on the repository server. By that, it's making sure it uses the same umask
-  for remote repos as for local ones. Because of this, you must upgrade both
-  server and client(s) to 0.24.
-- the default umask is 077 now (if you do not specify via --umask) which might
-  be a different one as you used previously. The default umask avoids that
-  you accidentally give access permissions for group and/or others to files
-  created by borg (e.g. the repository).
-
-Deprecations:
-
-- "--encryption passphrase" mode is deprecated, see #85 and #97.
-  See the new "--encryption repokey" mode for a replacement.
-
-New features:
-
-- borg create --chunker-params ... to configure the chunker, fixes #16
-  (attic #302, attic #300, and somehow also #41).
-  This can be used to reduce memory usage caused by chunk management overhead,
-  so borg does not create a huge chunks index/repo index and eats all your RAM
-  if you back up lots of data in huge files (like VM disk images).
-  See docs/misc/create_chunker-params.txt for more information.
-- borg info now reports chunk counts in the chunk index.
-- borg create --compression 0..9 to select zlib compression level, fixes #66
-  (attic #295).
-- borg init --encryption repokey (to store the encryption key into the repo),
-  fixes #85
-- improve at-end error logging, always log exceptions and set exit_code=1
-- LoggedIO: better error checks / exceptions / exception handling
-- implement --remote-path to allow non-default-path borg locations, #125
-- implement --umask M and use 077 as default umask for better security, #117
-- borg check: give a named single archive to it, fixes #139
-- cache sync: show progress indication
-- cache sync: reimplement the chunk index merging in C
-
-Bug fixes:
-
-- fix segfault that happened for unreadable files (chunker: n needs to be a
-  signed size_t), #116
-- fix the repair mode, #144
-- repo delete: add destroy to allowed rpc methods, fixes issue #114
-- more compatible repository locking code (based on mkdir), maybe fixes #92
-  (attic #317, attic #201).
-- better Exception msg if no Borg is installed on the remote repo server, #56
-- create a RepositoryCache implementation that can cope with >2GiB,
-  fixes attic #326.
-- fix Traceback when running check --repair, attic #232
-- clarify help text, fixes #73.
-- add help string for --no-files-cache, fixes #140
-
-Other changes:
-
-- improved docs:
-
-  - added docs/misc directory for misc. writeups that won't be included
-    "as is" into the html docs.
-  - document environment variables and return codes (attic #324, attic #52)
-  - web site: add related projects, fix web site url, IRC #borgbackup
-  - Fedora/Fedora-based install instructions added to docs
-  - Cygwin-based install instructions added to docs
-  - updated AUTHORS
-  - add FAQ entries about redundancy / integrity
-  - clarify that borg extract uses the cwd as extraction target
-  - update internals doc about chunker params, memory usage and compression
-  - added docs about development
-  - add some words about resource usage in general
-  - document how to backup a raw disk
-  - add note about how to run borg from virtual env
-  - add solutions for (ll)fuse installation problems
-  - document what borg check does, fixes #138
-  - reorganize borgbackup.github.io sidebar, prev/next at top
-  - deduplicate and refactor the docs / README.rst
-
-- use borg-tmp as prefix for temporary files / directories
-- short prune options without "keep-" are deprecated, do not suggest them
-- improved tox configuration
-- remove usage of unittest.mock, always use mock from pypi
-- use entrypoints instead of scripts, for better use of the wheel format and
-  modern installs
-- add requirements.d/development.txt and modify tox.ini
-- use travis-ci for testing based on Linux and (new) OS X
-- use coverage.py, pytest-cov and codecov.io for test coverage support
-
-I forgot to list some stuff already implemented in 0.23.0, here they are:
-
-New features:
-
-- efficient archive list from manifest, meaning a big speedup for slow
-  repo connections and "list <repo>", "delete <repo>", "prune" (attic #242,
-  attic #167)
-- big speedup for chunks cache sync (esp. for slow repo connections), fixes #18
-- hashindex: improve error messages
-
-Other changes:
-
-- explicitly specify binary mode to open binary files
-- some easy micro optimizations
-
-
-Version 0.23.0 (2015-06-11)
----------------------------
-
-Incompatible changes (compared to attic, fork related):
-
-- changed sw name and cli command to "borg", updated docs
-- package name (and name in urls) uses "borgbackup" to have fewer collisions
-- changed repo / cache internal magic strings from ATTIC* to BORG*,
-  changed cache location to .cache/borg/ - this means that it currently won't
-  accept attic repos (see issue #21 about improving that)
-
-Bug fixes:
-
-- avoid defect python-msgpack releases, fixes attic #171, fixes attic #185
-- fix traceback when trying to do unsupported passphrase change, fixes attic #189
-- datetime does not like the year 10.000, fixes attic #139
-- fix "info" all archives stats, fixes attic #183
-- fix parsing with missing microseconds, fixes attic #282
-- fix misleading hint the fuse ImportError handler gave, fixes attic #237
-- check unpacked data from RPC for tuple type and correct length, fixes attic #127
-- fix Repository._active_txn state when lock upgrade fails
-- give specific path to xattr.is_enabled(), disable symlink setattr call that
-  always fails
-- fix test setup for 32bit platforms, partial fix for attic #196
-- upgraded versioneer, PEP440 compliance, fixes attic #257
-
-New features:
-
-- less memory usage: add global option --no-cache-files
-- check --last N (only check the last N archives)
-- check: sort archives in reverse time order
-- rename repo::oldname newname (rename repository)
-- create -v output more informative
-- create --progress (backup progress indicator)
-- create --timestamp (utc string or reference file/dir)
-- create: if "-" is given as path, read binary from stdin
-- extract: if --stdout is given, write all extracted binary data to stdout
-- extract --sparse (simple sparse file support)
-- extra debug information for 'fread failed'
-- delete <repo> (deletes whole repo + local cache)
-- FUSE: reflect deduplication in allocated blocks
-- only allow whitelisted RPC calls in server mode
-- normalize source/exclude paths before matching
-- use posix_fadvise to not spoil the OS cache, fixes attic #252
-- toplevel error handler: show tracebacks for better error analysis
-- sigusr1 / sigint handler to print current file infos - attic PR #286
-- RPCError: include the exception args we get from remote
-
-Other changes:
-
-- source: misc. cleanups, pep8, style
-- docs and faq improvements, fixes, updates
-- cleanup crypto.pyx, make it easier to adapt to other AES modes
-- do os.fsync like recommended in the python docs
-- source: Let chunker optionally work with os-level file descriptor.
-- source: Linux: remove duplicate os.fsencode calls
-- source: refactor _open_rb code a bit, so it is more consistent / regular
-- source: refactor indicator (status) and item processing
-- source: use py.test for better testing, flake8 for code style checks
-- source: fix tox >=2.0 compatibility (test runner)
-- pypi package: add python version classifiers, add FreeBSD to platforms
-
-
-Attic Changelog
----------------
-
-Here you can see the full list of changes between each Attic release until Borg
-forked from Attic:
-
-Version 0.17
-~~~~~~~~~~~~
-
-(bugfix release, released on X)
-
-- Fix hashindex ARM memory alignment issue (#309)
-- Improve hashindex error messages (#298)
-
-Version 0.16
-~~~~~~~~~~~~
-
-(bugfix release, released on May 16, 2015)
-
-- Fix typo preventing the security confirmation prompt from working (#303)
-- Improve handling of systems with improperly configured file system encoding (#289)
-- Fix "All archives" output for attic info. (#183)
-- More user friendly error message when repository key file is not found (#236)
-- Fix parsing of iso 8601 timestamps with zero microseconds (#282)
-
-Version 0.15
-~~~~~~~~~~~~
-
-(bugfix release, released on Apr 15, 2015)
-
-- xattr: Be less strict about unknown/unsupported platforms (#239)
-- Reduce repository listing memory usage (#163).
-- Fix BrokenPipeError for remote repositories (#233)
-- Fix incorrect behavior with two character directory names (#265, #268)
-- Require approval before accessing relocated/moved repository (#271)
-- Require approval before accessing previously unknown unencrypted repositories (#271)
-- Fix issue with hash index files larger than 2GB.
-- Fix Python 3.2 compatibility issue with noatime open() (#164)
-- Include missing pyx files in dist files (#168)
-
-Version 0.14
-~~~~~~~~~~~~
-
-(feature release, released on Dec 17, 2014)
-
-- Added support for stripping leading path segments (#95)
-  "attic extract --strip-segments X"
-- Add workaround for old Linux systems without acl_extended_file_no_follow (#96)
-- Add MacPorts' path to the default openssl search path (#101)
-- HashIndex improvements, eliminates unnecessary IO on low memory systems.
-- Fix "Number of files" output for attic info. (#124)
-- limit create file permissions so files aren't read while restoring
-- Fix issue with empty xattr values (#106)
-
-Version 0.13
-~~~~~~~~~~~~
-
-(feature release, released on Jun 29, 2014)
-
-- Fix sporadic "Resource temporarily unavailable" when using remote repositories
-- Reduce file cache memory usage (#90)
-- Faster AES encryption (utilizing AES-NI when available)
-- Experimental Linux, OS X and FreeBSD ACL support (#66)
-- Added support for backup and restore of BSDFlags (OSX, FreeBSD) (#56)
-- Fix bug where xattrs on symlinks were not correctly restored
-- Added cachedir support. CACHEDIR.TAG compatible cache directories
-  can now be excluded using ``--exclude-caches`` (#74)
-- Fix crash on extreme mtime timestamps (year 2400+) (#81)
-- Fix Python 3.2 specific lockf issue (EDEADLK)
-
-Version 0.12
-~~~~~~~~~~~~
-
-(feature release, released on April 7, 2014)
-
-- Python 3.4 support (#62)
-- Various documentation improvements a new style
-- ``attic mount`` now supports mounting an entire repository not only
-  individual archives (#59)
-- Added option to restrict remote repository access to specific path(s):
-  ``attic serve --restrict-to-path X`` (#51)
-- Include "all archives" size information in "--stats" output. (#54)
-- Added ``--stats`` option to ``attic delete`` and ``attic prune``
-- Fixed bug where ``attic prune`` used UTC instead of the local time zone
-  when determining which archives to keep.
-- Switch to SI units (Power of 1000 instead 1024) when printing file sizes
-
-Version 0.11
-~~~~~~~~~~~~
-
-(feature release, released on March 7, 2014)
-
-- New "check" command for repository consistency checking (#24)
-- Documentation improvements
-- Fix exception during "attic create" with repeated files (#39)
-- New "--exclude-from" option for attic create/extract/verify.
-- Improved archive metadata deduplication.
-- "attic verify" has been deprecated. Use "attic extract --dry-run" instead.
-- "attic prune --hourly|daily|..." has been deprecated.
-  Use "attic prune --keep-hourly|daily|..." instead.
-- Ignore xattr errors during "extract" if not supported by the filesystem. (#46)
-
-Version 0.10
-~~~~~~~~~~~~
-
-(bugfix release, released on Jan 30, 2014)
-
-- Fix deadlock when extracting 0 sized files from remote repositories
-- "--exclude" wildcard patterns are now properly applied to the full path
-  not just the file name part (#5).
-- Make source code endianness agnostic (#1)
-
-Version 0.9
-~~~~~~~~~~~
-
-(feature release, released on Jan 23, 2014)
-
-- Remote repository speed and reliability improvements.
-- Fix sorting of segment names to ignore NFS left over files. (#17)
-- Fix incorrect display of time (#13)
-- Improved error handling / reporting. (#12)
-- Use fcntl() instead of flock() when locking repository/cache. (#15)
-- Let ssh figure out port/user if not specified so we don't override .ssh/config (#9)
-- Improved libcrypto path detection (#23).
-
-Version 0.8.1
-~~~~~~~~~~~~~
-
-(bugfix release, released on Oct 4, 2013)
-
-- Fix segmentation fault issue.
-
-Version 0.8
-~~~~~~~~~~~
-
-(feature release, released on Oct 3, 2013)
-
-- Fix xattr issue when backing up sshfs filesystems (#4)
-- Fix issue with excessive index file size (#6)
-- Support access of read only repositories.
-- New syntax to enable repository encryption:
-    attic init --encryption="none|passphrase|keyfile".
-- Detect and abort if repository is older than the cache.
-
-
-Version 0.7
-~~~~~~~~~~~
-
-(feature release, released on Aug 5, 2013)
-
-- Ported to FreeBSD
-- Improved documentation
-- Experimental: Archives mountable as FUSE filesystems.
-- The "user." prefix is no longer stripped from xattrs on Linux
-
-
-Version 0.6.1
-~~~~~~~~~~~~~
-
-(bugfix release, released on July 19, 2013)
-
-- Fixed an issue where mtime was not always correctly restored.
-
-
-Version 0.6
-~~~~~~~~~~~
-
-First public release on July 9, 2013
diff --git a/docs/changes_0.x.rst b/docs/changes_0.x.rst
new file mode 100644
index 000000000..52c0b0352
--- /dev/null
+++ b/docs/changes_0.x.rst
@@ -0,0 +1,807 @@
+.. _changelog_0x:
+
+Change Log 0.x
+==============
+
+Version 0.30.0 (2016-01-23)
+---------------------------
+
+Compatibility notes:
+
+- you may need to use -v (or --info) more often to actually see output emitted
+  at INFO log level (because it is suppressed at the default WARNING log level).
+  See the "general" section in the usage docs.
+- for borg create, you need --list (additionally to -v) to see the long file
+  list (was needed so you can have e.g. --stats alone without the long list)
+- see below about BORG_DELETE_I_KNOW_WHAT_I_AM_DOING (was:
+  BORG_CHECK_I_KNOW_WHAT_I_AM_DOING)
+
+Bug fixes:
+
+- fix crash when using borg create --dry-run --keep-tag-files, #570
+- make sure teardown with cleanup happens for Cache and RepositoryCache,
+  avoiding leftover locks and TEMP dir contents, #285 (partially), #548
+- fix locking KeyError, partial fix for #502
+- log stats consistently, #526
+- add abbreviated weekday to timestamp format, fixes #496
+- strip whitespace when loading exclusions from file
+- unset LD_LIBRARY_PATH before invoking ssh, fixes strange OpenSSL library
+  version warning when using the borg binary, #514
+- add some error handling/fallback for C library loading, #494
+- added BORG_DELETE_I_KNOW_WHAT_I_AM_DOING for check in "borg delete", #503
+- remove unused "repair" rpc method name
+
+New features:
+
+- borg create: implement exclusions using regular expression patterns.
+- borg create: implement inclusions using patterns.
+- borg extract: support patterns, #361
+- support different styles for patterns:
+
+  - fnmatch (`fm:` prefix, default when omitted), like borg <= 0.29.
+  - shell (`sh:` prefix) with `*` not matching directory separators and
+    `**/` matching 0..n directories
+  - path prefix (`pp:` prefix, for unifying borg create pp1 pp2 into the
+    patterns system), semantics like in borg <= 0.29
+  - regular expression (`re:`), new!
+- --progress option for borg upgrade (#291) and borg delete <archive>
+- update progress indication more often (e.g. for borg create within big
+  files or for borg check repo), #500
+- finer chunker granularity for items metadata stream, #547, #487
+- borg create --list now used (additionally to -v) to enable the verbose
+  file list output
+- display borg version below tracebacks, #532
+
+Other changes:
+
+- hashtable size (and thus: RAM and disk consumption) follows a growth policy:
+  grows fast while small, grows slower when getting bigger, #527
+- Vagrantfile: use pyinstaller 3.1 to build binaries, freebsd sqlite3 fix,
+  fixes #569
+- no separate binaries for centos6 any more because the generic linux binaries
+  also work on centos6 (or in general: on systems with a slightly older glibc
+  than debian7
+- dev environment: require virtualenv<14.0 so we get a py32 compatible pip
+- docs:
+
+  - add space-saving chunks.archive.d trick to FAQ
+  - important: clarify -v and log levels in usage -> general, please read!
+  - sphinx configuration: create a simple man page from usage docs
+  - add a repo server setup example
+  - disable unneeded SSH features in authorized_keys examples for security.
+  - borg prune only knows "--keep-within" and not "--within"
+  - add gource video to resources docs, #507
+  - add netbsd install instructions
+  - authors: make it more clear what refers to borg and what to attic
+  - document standalone binary requirements, #499
+  - rephrase the mailing list section
+  - development docs: run build_api and build_usage before tagging release
+  - internals docs: hash table max. load factor is 0.75 now
+  - markup, typo, grammar, phrasing, clarifications and other fixes.
+  - add gcc gcc-c++ to redhat/fedora/corora install docs, fixes #583
+
+
+Version 0.29.0 (2015-12-13)
+---------------------------
+
+Compatibility notes:
+
+- when upgrading to 0.29.0 you need to upgrade client as well as server
+  installations due to the locking and commandline interface changes otherwise
+  you'll get an error msg about a RPC protocol mismatch or a wrong commandline
+  option.
+  if you run a server that needs to support both old and new clients, it is
+  suggested that you have a "borg-0.28.2" and a "borg-0.29.0" command.
+  clients then can choose via e.g. "borg --remote-path=borg-0.29.0 ...".
+- the default waiting time for a lock changed from infinity to 1 second for a
+  better interactive user experience. if the repo you want to access is
+  currently locked, borg will now terminate after 1s with an error message.
+  if you have scripts that shall wait for the lock for a longer time, use
+  --lock-wait N (with N being the maximum wait time in seconds).
+
+Bug fixes:
+
+- hash table tuning (better chosen hashtable load factor 0.75 and prime initial
+  size of 1031 gave ~1000x speedup in some scenarios)
+- avoid creation of an orphan lock for one case, #285
+- --keep-tag-files: fix file mode and multiple tag files in one directory, #432
+- fixes for "borg upgrade" (attic repo converter), #466
+- remove --progress isatty magic (and also --no-progress option) again, #476
+- borg init: display proper repo URL
+- fix format of umask in help pages, #463
+
+New features:
+
+- implement --lock-wait, support timeout for UpgradableLock, #210
+- implement borg break-lock command, #157
+- include system info below traceback, #324
+- sane remote logging, remote stderr, #461:
+
+  - remote log output: intercept it and log it via local logging system,
+    with "Remote: " prefixed to message. log remote tracebacks.
+  - remote stderr: output it to local stderr with "Remote: " prefixed.
+- add --debug and --info (same as --verbose) to set the log level of the
+  builtin logging configuration (which otherwise defaults to warning), #426
+  note: there are few messages emitted at DEBUG level currently.
+- optionally configure logging via env var BORG_LOGGING_CONF
+- add --filter option for status characters: e.g. to show only the added
+  or modified files (and also errors), use "borg create -v --filter=AME ...".
+- more progress indicators, #394
+- use ISO-8601 date and time format, #375
+- "borg check --prefix" to restrict archive checking to that name prefix, #206
+
+Other changes:
+
+- hashindex_add C implementation (speed up cache re-sync for new archives)
+- increase FUSE read_size to 1024 (speed up metadata operations)
+- check/delete/prune --save-space: free unused segments quickly, #239
+- increase rpc protocol version to 2 (see also Compatibility notes), #458
+- silence borg by default (via default log level WARNING)
+- get rid of C compiler warnings, #391
+- upgrade OS X FUSE to 3.0.9 on the OS X binary build system
+- use python 3.5.1 to build binaries
+- docs:
+
+  - new mailing list borgbackup@python.org, #468
+  - readthedocs: color and logo improvements
+  - load coverage icons over SSL (avoids mixed content)
+  - more precise binary installation steps
+  - update release procedure docs about OS X FUSE
+  - FAQ entry about unexpected 'A' status for unchanged file(s), #403
+  - add docs about 'E' file status
+  - add "borg upgrade" docs, #464
+  - add developer docs about output and logging
+  - clarify encryption, add note about client-side encryption
+  - add resources section, with videos, talks, presentations, #149
+  - Borg moved to Arch Linux [community]
+  - fix wrong installation instructions for archlinux
+
+
+Version 0.28.2 (2015-11-15)
+---------------------------
+
+New features:
+
+- borg create --exclude-if-present TAGFILE - exclude directories that have the
+  given file from the backup. You can additionally give --keep-tag-files to
+  preserve just the directory roots and the tag-files (but not backup other
+  directory contents), #395, attic #128, attic #142
+
+Other changes:
+
+- do not create docs sources at build time (just have them in the repo),
+  completely remove have_cython() hack, do not use the "mock" library at build
+  time, #384
+- avoid hidden import, make it easier for PyInstaller, easier fix for #218
+- docs:
+
+  - add description of item flags / status output, fixes #402
+  - explain how to regenerate usage and API files (build_api or
+    build_usage) and when to commit usage files directly into git, #384
+  - minor install docs improvements
+
+
+Version 0.28.1 (2015-11-08)
+---------------------------
+
+Bug fixes:
+
+- do not try to build api / usage docs for production install,
+  fixes unexpected "mock" build dependency, #384
+
+Other changes:
+
+- avoid using msgpack.packb at import time
+- fix formatting issue in changes.rst
+- fix build on readthedocs
+
+
+Version 0.28.0 (2015-11-08)
+---------------------------
+
+Compatibility notes:
+
+- changed return codes (exit codes), see docs. in short:
+  old: 0 = ok, 1 = error. now: 0 = ok, 1 = warning, 2 = error
+
+New features:
+
+- refactor return codes (exit codes), fixes #61
+- add --show-rc option enable "terminating with X status, rc N" output, fixes 58, #351
+- borg create backups atime and ctime additionally to mtime, fixes #317
+  - extract: support atime additionally to mtime
+  - FUSE: support ctime and atime additionally to mtime
+- support borg --version
+- emit a warning if we have a slow msgpack installed
+- borg list --prefix=thishostname- REPO, fixes #205
+- Debug commands (do not use except if you know what you do: debug-get-obj,
+  debug-put-obj, debug-delete-obj, debug-dump-archive-items.
+
+Bug fixes:
+
+- setup.py: fix bug related to BORG_LZ4_PREFIX processing
+- fix "check" for repos that have incomplete chunks, fixes #364
+- borg mount: fix unlocking of repository at umount time, fixes #331
+- fix reading files without touching their atime, #334
+- non-ascii ACL fixes for Linux, FreeBSD and OS X, #277
+- fix acl_use_local_uid_gid() and add a test for it, attic #359
+- borg upgrade: do not upgrade repositories in place by default, #299
+- fix cascading failure with the index conversion code, #269
+- borg check: implement 'cmdline' archive metadata value decoding, #311
+- fix RobustUnpacker, it missed some metadata keys (new atime and ctime keys
+  were missing, but also bsdflags). add check for unknown metadata keys.
+- create from stdin: also save atime, ctime (cosmetic)
+- use default_notty=False for confirmations, fixes #345
+- vagrant: fix msgpack installation on centos, fixes #342
+- deal with unicode errors for symlinks in same way as for regular files and
+  have a helpful warning message about how to fix wrong locale setup, fixes #382
+- add ACL keys the RobustUnpacker must know about
+
+Other changes:
+
+- improve file size displays, more flexible size formatters
+- explicitly commit to the units standard, #289
+- archiver: add E status (means that an error occurred when processing this
+  (single) item
+- do binary releases via "github releases", closes #214
+- create: use -x and --one-file-system (was: --do-not-cross-mountpoints), #296
+- a lot of changes related to using "logging" module and screen output, #233
+- show progress display if on a tty, output more progress information, #303
+- factor out status output so it is consistent, fix surrogates removal,
+  maybe fixes #309
+- move away from RawConfigParser to ConfigParser
+- archive checker: better error logging, give chunk_id and sequence numbers
+  (can be used together with borg debug-dump-archive-items).
+- do not mention the deprecated passphrase mode
+- emit a deprecation warning for --compression N (giving a just a number)
+- misc .coverragerc fixes (and coverage measurement improvements), fixes #319
+- refactor confirmation code, reduce code duplication, add tests
+- prettier error messages, fixes #307, #57
+- tests:
+
+  - add a test to find disk-full issues, #327
+  - travis: also run tests on Python 3.5
+  - travis: use tox -r so it rebuilds the tox environments
+  - test the generated pyinstaller-based binary by archiver unit tests, #215
+  - vagrant: tests: announce whether fakeroot is used or not
+  - vagrant: add vagrant user to fuse group for debianoid systems also
+  - vagrant: llfuse install on darwin needs pkgconfig installed
+  - vagrant: use pyinstaller from develop branch, fixes #336
+  - benchmarks: test create, extract, list, delete, info, check, help, fixes #146
+  - benchmarks: test with both the binary and the python code
+  - archiver tests: test with both the binary and the python code, fixes #215
+  - make basic test more robust
+- docs:
+
+  - moved docs to borgbackup.readthedocs.org, #155
+  - a lot of fixes and improvements, use mobile-friendly RTD standard theme
+  - use zlib,6 compression in some examples, fixes #275
+  - add missing rename usage to docs, closes #279
+  - include the help offered by borg help <topic> in the usage docs, fixes #293
+  - include a list of major changes compared to attic into README, fixes #224
+  - add OS X install instructions, #197
+  - more details about the release process, #260
+  - fix linux glibc requirement (binaries built on debian7 now)
+  - build: move usage and API generation to setup.py
+  - update docs about return codes, #61
+  - remove api docs (too much breakage on rtd)
+  - borgbackup install + basics presentation (asciinema)
+  - describe the current style guide in documentation
+  - add section about debug commands
+  - warn about not running out of space
+  - add example for rename
+  - improve chunker params docs, fixes #362
+  - minor development docs update
+
+
+Version 0.27.0 (2015-10-07)
+---------------------------
+
+New features:
+
+- "borg upgrade" command - attic -> borg one time converter / migration, #21
+- temporary hack to avoid using lots of disk space for chunks.archive.d, #235:
+  To use it: rm -rf chunks.archive.d ; touch chunks.archive.d
+- respect XDG_CACHE_HOME, attic #181
+- add support for arbitrary SSH commands, attic #99
+- borg delete --cache-only REPO (only delete cache, not REPO), attic #123
+
+
+Bug fixes:
+
+- use Debian 7 (wheezy) to build pyinstaller borgbackup binaries, fixes slow
+  down observed when running the Centos6-built binary on Ubuntu, #222
+- do not crash on empty lock.roster, fixes #232
+- fix multiple issues with the cache config version check, #234
+- fix segment entry header size check, attic #352
+  plus other error handling improvements / code deduplication there.
+- always give segment and offset in repo IntegrityErrors
+
+
+Other changes:
+
+- stop producing binary wheels, remove docs about it, #147
+- docs:
+  - add warning about prune
+  - generate usage include files only as needed
+  - development docs: add Vagrant section
+  - update / improve / reformat FAQ
+  - hint to single-file pyinstaller binaries from README
+
+
+Version 0.26.1 (2015-09-28)
+---------------------------
+
+This is a minor update, just docs and new pyinstaller binaries.
+
+- docs update about python and binary requirements
+- better docs for --read-special, fix #220
+- re-built the binaries, fix #218 and #213 (glibc version issue)
+- update web site about single-file pyinstaller binaries
+
+Note: if you did a python-based installation, there is no need to upgrade.
+
+
+Version 0.26.0 (2015-09-19)
+---------------------------
+
+New features:
+
+- Faster cache sync (do all in one pass, remove tar/compression stuff), #163
+- BORG_REPO env var to specify the default repo, #168
+- read special files as if they were regular files, #79
+- implement borg create --dry-run, attic issue #267
+- Normalize paths before pattern matching on OS X, #143
+- support OpenBSD and NetBSD (except xattrs/ACLs)
+- support / run tests on Python 3.5
+
+Bug fixes:
+
+- borg mount repo: use absolute path, attic #200, attic #137
+- chunker: use off_t to get 64bit on 32bit platform, #178
+- initialize chunker fd to -1, so it's not equal to STDIN_FILENO (0)
+- fix reaction to "no" answer at delete repo prompt, #182
+- setup.py: detect lz4.h header file location
+- to support python < 3.2.4, add less buggy argparse lib from 3.2.6 (#194)
+- fix for obtaining ``char *`` from temporary Python value (old code causes
+  a compile error on Mint 17.2)
+- llfuse 0.41 install troubles on some platforms, require < 0.41
+  (UnicodeDecodeError exception due to non-ascii llfuse setup.py)
+- cython code: add some int types to get rid of unspecific python add /
+  subtract operations (avoid ``undefined symbol FPE_``... error on some platforms)
+- fix verbose mode display of stdin backup
+- extract: warn if a include pattern never matched, fixes #209,
+  implement counters for Include/ExcludePatterns
+- archive names with slashes are invalid, attic issue #180
+- chunker: add a check whether the POSIX_FADV_DONTNEED constant is defined -
+  fixes building on OpenBSD.
+
+Other changes:
+
+- detect inconsistency / corruption / hash collision, #170
+- replace versioneer with setuptools_scm, #106
+- docs:
+
+  - pkg-config is needed for llfuse installation
+  - be more clear about pruning, attic issue #132
+- unit tests:
+
+  - xattr: ignore security.selinux attribute showing up
+  - ext3 seems to need a bit more space for a sparse file
+  - do not test lzma level 9 compression (avoid MemoryError)
+  - work around strange mtime granularity issue on netbsd, fixes #204
+  - ignore st_rdev if file is not a block/char device, fixes #203
+  - stay away from the setgid and sticky mode bits
+- use Vagrant to do easy cross-platform testing (#196), currently:
+
+  - Debian 7 "wheezy" 32bit, Debian 8 "jessie" 64bit
+  - Ubuntu 12.04 32bit, Ubuntu 14.04 64bit
+  - Centos 7 64bit
+  - FreeBSD 10.2 64bit
+  - OpenBSD 5.7 64bit
+  - NetBSD 6.1.5 64bit
+  - Darwin (OS X Yosemite)
+
+
+Version 0.25.0 (2015-08-29)
+---------------------------
+
+Compatibility notes:
+
+- lz4 compression library (liblz4) is a new requirement (#156)
+- the new compression code is very compatible: as long as you stay with zlib
+  compression, older borg releases will still be able to read data from a
+  repo/archive made with the new code (note: this is not the case for the
+  default "none" compression, use "zlib,0" if you want a "no compression" mode
+  that can be read by older borg). Also the new code is able to read repos and
+  archives made with older borg versions (for all zlib levels  0..9).
+
+Deprecations:
+
+- --compression N (with N being a number, as in 0.24) is deprecated.
+  We keep the --compression 0..9 for now to not break scripts, but it is
+  deprecated and will be removed later, so better fix your scripts now:
+  --compression 0 (as in 0.24) is the same as --compression zlib,0 (now).
+  BUT: if you do not want compression, you rather want --compression none
+  (which is the default).
+  --compression 1 (in 0.24) is the same as --compression zlib,1 (now)
+  --compression 9 (in 0.24) is the same as --compression zlib,9 (now)
+
+New features:
+
+- create --compression none (default, means: do not compress, just pass through
+  data "as is". this is more efficient than zlib level 0 as used in borg 0.24)
+- create --compression lz4 (super-fast, but not very high compression)
+- create --compression zlib,N (slower, higher compression, default for N is 6)
+- create --compression lzma,N (slowest, highest compression, default N is 6)
+- honor the nodump flag (UF_NODUMP) and do not backup such items
+- list --short just outputs a simple list of the files/directories in an archive
+
+Bug fixes:
+
+- fixed --chunker-params parameter order confusion / malfunction, fixes #154
+- close fds of segments we delete (during compaction)
+- close files which fell out the lrucache
+- fadvise DONTNEED now is only called for the byte range actually read, not for
+  the whole file, fixes #158.
+- fix issue with negative "all archives" size, fixes #165
+- restore_xattrs: ignore if setxattr fails with EACCES, fixes #162
+
+Other changes:
+
+- remove fakeroot requirement for tests, tests run faster without fakeroot
+  (test setup does not fail any more without fakeroot, so you can run with or
+  without fakeroot), fixes #151 and #91.
+- more tests for archiver
+- recover_segment(): don't assume we have an fd for segment
+- lrucache refactoring / cleanup, add dispose function, py.test tests
+- generalize hashindex code for any key length (less hardcoding)
+- lock roster: catch file not found in remove() method and ignore it
+- travis CI: use requirements file
+- improved docs:
+
+  - replace hack for llfuse with proper solution (install libfuse-dev)
+  - update docs about compression
+  - update development docs about fakeroot
+  - internals: add some words about lock files / locking system
+  - support: mention BountySource and for what it can be used
+  - theme: use a lighter green
+  - add pypi, wheel, dist package based install docs
+  - split install docs into system-specific preparations and generic instructions
+
+
+Version 0.24.0 (2015-08-09)
+---------------------------
+
+Incompatible changes (compared to 0.23):
+
+- borg now always issues --umask NNN option when invoking another borg via ssh
+  on the repository server. By that, it's making sure it uses the same umask
+  for remote repos as for local ones. Because of this, you must upgrade both
+  server and client(s) to 0.24.
+- the default umask is 077 now (if you do not specify via --umask) which might
+  be a different one as you used previously. The default umask avoids that
+  you accidentally give access permissions for group and/or others to files
+  created by borg (e.g. the repository).
+
+Deprecations:
+
+- "--encryption passphrase" mode is deprecated, see #85 and #97.
+  See the new "--encryption repokey" mode for a replacement.
+
+New features:
+
+- borg create --chunker-params ... to configure the chunker, fixes #16
+  (attic #302, attic #300, and somehow also #41).
+  This can be used to reduce memory usage caused by chunk management overhead,
+  so borg does not create a huge chunks index/repo index and eats all your RAM
+  if you back up lots of data in huge files (like VM disk images).
+  See docs/misc/create_chunker-params.txt for more information.
+- borg info now reports chunk counts in the chunk index.
+- borg create --compression 0..9 to select zlib compression level, fixes #66
+  (attic #295).
+- borg init --encryption repokey (to store the encryption key into the repo),
+  fixes #85
+- improve at-end error logging, always log exceptions and set exit_code=1
+- LoggedIO: better error checks / exceptions / exception handling
+- implement --remote-path to allow non-default-path borg locations, #125
+- implement --umask M and use 077 as default umask for better security, #117
+- borg check: give a named single archive to it, fixes #139
+- cache sync: show progress indication
+- cache sync: reimplement the chunk index merging in C
+
+Bug fixes:
+
+- fix segfault that happened for unreadable files (chunker: n needs to be a
+  signed size_t), #116
+- fix the repair mode, #144
+- repo delete: add destroy to allowed rpc methods, fixes issue #114
+- more compatible repository locking code (based on mkdir), maybe fixes #92
+  (attic #317, attic #201).
+- better Exception msg if no Borg is installed on the remote repo server, #56
+- create a RepositoryCache implementation that can cope with >2GiB,
+  fixes attic #326.
+- fix Traceback when running check --repair, attic #232
+- clarify help text, fixes #73.
+- add help string for --no-files-cache, fixes #140
+
+Other changes:
+
+- improved docs:
+
+  - added docs/misc directory for misc. writeups that won't be included
+    "as is" into the html docs.
+  - document environment variables and return codes (attic #324, attic #52)
+  - web site: add related projects, fix web site url, IRC #borgbackup
+  - Fedora/Fedora-based install instructions added to docs
+  - Cygwin-based install instructions added to docs
+  - updated AUTHORS
+  - add FAQ entries about redundancy / integrity
+  - clarify that borg extract uses the cwd as extraction target
+  - update internals doc about chunker params, memory usage and compression
+  - added docs about development
+  - add some words about resource usage in general
+  - document how to backup a raw disk
+  - add note about how to run borg from virtual env
+  - add solutions for (ll)fuse installation problems
+  - document what borg check does, fixes #138
+  - reorganize borgbackup.github.io sidebar, prev/next at top
+  - deduplicate and refactor the docs / README.rst
+
+- use borg-tmp as prefix for temporary files / directories
+- short prune options without "keep-" are deprecated, do not suggest them
+- improved tox configuration
+- remove usage of unittest.mock, always use mock from pypi
+- use entrypoints instead of scripts, for better use of the wheel format and
+  modern installs
+- add requirements.d/development.txt and modify tox.ini
+- use travis-ci for testing based on Linux and (new) OS X
+- use coverage.py, pytest-cov and codecov.io for test coverage support
+
+I forgot to list some stuff already implemented in 0.23.0, here they are:
+
+New features:
+
+- efficient archive list from manifest, meaning a big speedup for slow
+  repo connections and "list <repo>", "delete <repo>", "prune" (attic #242,
+  attic #167)
+- big speedup for chunks cache sync (esp. for slow repo connections), fixes #18
+- hashindex: improve error messages
+
+Other changes:
+
+- explicitly specify binary mode to open binary files
+- some easy micro optimizations
+
+
+Version 0.23.0 (2015-06-11)
+---------------------------
+
+Incompatible changes (compared to attic, fork related):
+
+- changed sw name and cli command to "borg", updated docs
+- package name (and name in urls) uses "borgbackup" to have fewer collisions
+- changed repo / cache internal magic strings from ATTIC* to BORG*,
+  changed cache location to .cache/borg/ - this means that it currently won't
+  accept attic repos (see issue #21 about improving that)
+
+Bug fixes:
+
+- avoid defect python-msgpack releases, fixes attic #171, fixes attic #185
+- fix traceback when trying to do unsupported passphrase change, fixes attic #189
+- datetime does not like the year 10.000, fixes attic #139
+- fix "info" all archives stats, fixes attic #183
+- fix parsing with missing microseconds, fixes attic #282
+- fix misleading hint the fuse ImportError handler gave, fixes attic #237
+- check unpacked data from RPC for tuple type and correct length, fixes attic #127
+- fix Repository._active_txn state when lock upgrade fails
+- give specific path to xattr.is_enabled(), disable symlink setattr call that
+  always fails
+- fix test setup for 32bit platforms, partial fix for attic #196
+- upgraded versioneer, PEP440 compliance, fixes attic #257
+
+New features:
+
+- less memory usage: add global option --no-cache-files
+- check --last N (only check the last N archives)
+- check: sort archives in reverse time order
+- rename repo::oldname newname (rename repository)
+- create -v output more informative
+- create --progress (backup progress indicator)
+- create --timestamp (utc string or reference file/dir)
+- create: if "-" is given as path, read binary from stdin
+- extract: if --stdout is given, write all extracted binary data to stdout
+- extract --sparse (simple sparse file support)
+- extra debug information for 'fread failed'
+- delete <repo> (deletes whole repo + local cache)
+- FUSE: reflect deduplication in allocated blocks
+- only allow whitelisted RPC calls in server mode
+- normalize source/exclude paths before matching
+- use posix_fadvise to not spoil the OS cache, fixes attic #252
+- toplevel error handler: show tracebacks for better error analysis
+- sigusr1 / sigint handler to print current file infos - attic PR #286
+- RPCError: include the exception args we get from remote
+
+Other changes:
+
+- source: misc. cleanups, pep8, style
+- docs and faq improvements, fixes, updates
+- cleanup crypto.pyx, make it easier to adapt to other AES modes
+- do os.fsync like recommended in the python docs
+- source: Let chunker optionally work with os-level file descriptor.
+- source: Linux: remove duplicate os.fsencode calls
+- source: refactor _open_rb code a bit, so it is more consistent / regular
+- source: refactor indicator (status) and item processing
+- source: use py.test for better testing, flake8 for code style checks
+- source: fix tox >=2.0 compatibility (test runner)
+- pypi package: add python version classifiers, add FreeBSD to platforms
+
+
+Attic Changelog
+---------------
+
+Here you can see the full list of changes between each Attic release until Borg
+forked from Attic:
+
+Version 0.17
+~~~~~~~~~~~~
+
+(bugfix release, released on X)
+
+- Fix hashindex ARM memory alignment issue (#309)
+- Improve hashindex error messages (#298)
+
+Version 0.16
+~~~~~~~~~~~~
+
+(bugfix release, released on May 16, 2015)
+
+- Fix typo preventing the security confirmation prompt from working (#303)
+- Improve handling of systems with improperly configured file system encoding (#289)
+- Fix "All archives" output for attic info. (#183)
+- More user friendly error message when repository key file is not found (#236)
+- Fix parsing of iso 8601 timestamps with zero microseconds (#282)
+
+Version 0.15
+~~~~~~~~~~~~
+
+(bugfix release, released on Apr 15, 2015)
+
+- xattr: Be less strict about unknown/unsupported platforms (#239)
+- Reduce repository listing memory usage (#163).
+- Fix BrokenPipeError for remote repositories (#233)
+- Fix incorrect behavior with two character directory names (#265, #268)
+- Require approval before accessing relocated/moved repository (#271)
+- Require approval before accessing previously unknown unencrypted repositories (#271)
+- Fix issue with hash index files larger than 2GB.
+- Fix Python 3.2 compatibility issue with noatime open() (#164)
+- Include missing pyx files in dist files (#168)
+
+Version 0.14
+~~~~~~~~~~~~
+
+(feature release, released on Dec 17, 2014)
+
+- Added support for stripping leading path segments (#95)
+  "attic extract --strip-segments X"
+- Add workaround for old Linux systems without acl_extended_file_no_follow (#96)
+- Add MacPorts' path to the default openssl search path (#101)
+- HashIndex improvements, eliminates unnecessary IO on low memory systems.
+- Fix "Number of files" output for attic info. (#124)
+- limit create file permissions so files aren't read while restoring
+- Fix issue with empty xattr values (#106)
+
+Version 0.13
+~~~~~~~~~~~~
+
+(feature release, released on Jun 29, 2014)
+
+- Fix sporadic "Resource temporarily unavailable" when using remote repositories
+- Reduce file cache memory usage (#90)
+- Faster AES encryption (utilizing AES-NI when available)
+- Experimental Linux, OS X and FreeBSD ACL support (#66)
+- Added support for backup and restore of BSDFlags (OSX, FreeBSD) (#56)
+- Fix bug where xattrs on symlinks were not correctly restored
+- Added cachedir support. CACHEDIR.TAG compatible cache directories
+  can now be excluded using ``--exclude-caches`` (#74)
+- Fix crash on extreme mtime timestamps (year 2400+) (#81)
+- Fix Python 3.2 specific lockf issue (EDEADLK)
+
+Version 0.12
+~~~~~~~~~~~~
+
+(feature release, released on April 7, 2014)
+
+- Python 3.4 support (#62)
+- Various documentation improvements a new style
+- ``attic mount`` now supports mounting an entire repository not only
+  individual archives (#59)
+- Added option to restrict remote repository access to specific path(s):
+  ``attic serve --restrict-to-path X`` (#51)
+- Include "all archives" size information in "--stats" output. (#54)
+- Added ``--stats`` option to ``attic delete`` and ``attic prune``
+- Fixed bug where ``attic prune`` used UTC instead of the local time zone
+  when determining which archives to keep.
+- Switch to SI units (Power of 1000 instead 1024) when printing file sizes
+
+Version 0.11
+~~~~~~~~~~~~
+
+(feature release, released on March 7, 2014)
+
+- New "check" command for repository consistency checking (#24)
+- Documentation improvements
+- Fix exception during "attic create" with repeated files (#39)
+- New "--exclude-from" option for attic create/extract/verify.
+- Improved archive metadata deduplication.
+- "attic verify" has been deprecated. Use "attic extract --dry-run" instead.
+- "attic prune --hourly|daily|..." has been deprecated.
+  Use "attic prune --keep-hourly|daily|..." instead.
+- Ignore xattr errors during "extract" if not supported by the filesystem. (#46)
+
+Version 0.10
+~~~~~~~~~~~~
+
+(bugfix release, released on Jan 30, 2014)
+
+- Fix deadlock when extracting 0 sized files from remote repositories
+- "--exclude" wildcard patterns are now properly applied to the full path
+  not just the file name part (#5).
+- Make source code endianness agnostic (#1)
+
+Version 0.9
+~~~~~~~~~~~
+
+(feature release, released on Jan 23, 2014)
+
+- Remote repository speed and reliability improvements.
+- Fix sorting of segment names to ignore NFS left over files. (#17)
+- Fix incorrect display of time (#13)
+- Improved error handling / reporting. (#12)
+- Use fcntl() instead of flock() when locking repository/cache. (#15)
+- Let ssh figure out port/user if not specified so we don't override .ssh/config (#9)
+- Improved libcrypto path detection (#23).
+
+Version 0.8.1
+~~~~~~~~~~~~~
+
+(bugfix release, released on Oct 4, 2013)
+
+- Fix segmentation fault issue.
+
+Version 0.8
+~~~~~~~~~~~
+
+(feature release, released on Oct 3, 2013)
+
+- Fix xattr issue when backing up sshfs filesystems (#4)
+- Fix issue with excessive index file size (#6)
+- Support access of read only repositories.
+- New syntax to enable repository encryption:
+    attic init --encryption="none|passphrase|keyfile".
+- Detect and abort if repository is older than the cache.
+
+
+Version 0.7
+~~~~~~~~~~~
+
+(feature release, released on Aug 5, 2013)
+
+- Ported to FreeBSD
+- Improved documentation
+- Experimental: Archives mountable as FUSE filesystems.
+- The "user." prefix is no longer stripped from xattrs on Linux
+
+
+Version 0.6.1
+~~~~~~~~~~~~~
+
+(bugfix release, released on July 19, 2013)
+
+- Fixed an issue where mtime was not always correctly restored.
+
+
+Version 0.6
+~~~~~~~~~~~
+
+First public release on July 9, 2013
diff --git a/docs/changes_1.x.rst b/docs/changes_1.x.rst
new file mode 100644
index 000000000..16aad68d7
--- /dev/null
+++ b/docs/changes_1.x.rst
@@ -0,0 +1,4362 @@
+.. _important_notes_1x:
+
+Important notes 1.x
+===================
+
+This section provides information about security and corruption issues.
+
+.. _hashindex_set_bug:
+
+Pre-1.1.11 potential index corruption / data loss issue
+-------------------------------------------------------
+
+A bug was discovered in our hashtable code, see issue #4829.
+The code is used for the client-side chunks cache and the server-side repo index.
+
+Although borg uses the hashtables very heavily, the index corruption did not
+happen too frequently, because it needed specific conditions to happen.
+
+Data loss required even more specific conditions, so it should be rare (and
+also detectable via borg check).
+
+You might be affected if borg crashed with / complained about:
+
+- AssertionError: Corrupted segment reference count - corrupted index or hints
+- ObjectNotFound: Object with key ... not found in repository ...
+- Index mismatch for key b'...'. (..., ...) != (-1, -1)
+- ValueError: stats_against: key contained in self but not in master_index.
+
+Advised procedure to fix any related issue in your indexes/caches:
+
+- install fixed borg code (on client AND server)
+- for all of your clients and repos remove the cache by:
+
+  borg delete --cache-only YOURREPO
+
+  (later, the cache will be re-built automatically)
+- for all your repos, rebuild the repo index by:
+
+  borg check --repair YOURREPO
+
+  This will also check all archives and detect if there is any data-loss issue.
+
+Affected branches / releases:
+
+- fd06497 introduced the bug into 1.1-maint branch - it affects all borg 1.1.x since 1.1.0b4.
+- fd06497 introduced the bug into master branch - it affects all borg 1.2.0 alpha releases.
+- c5cd882 introduced the bug into 1.0-maint branch - it affects all borg 1.0.x since 1.0.11rc1.
+
+The bug was fixed by:
+
+- 701159a fixes the bug in 1.1-maint branch - will be released with borg 1.1.11.
+- fa63150 fixes the bug in master branch - will be released with borg 1.2.0a8.
+- 7bb90b6 fixes the bug in 1.0-maint branch. Branch is EOL, no new release is planned as of now.
+
+.. _broken_validator:
+
+Pre-1.1.4 potential data corruption issue
+-----------------------------------------
+
+A data corruption bug was discovered in borg check --repair, see issue #3444.
+
+This is a 1.1.x regression, releases < 1.1 (e.g. 1.0.x) are not affected.
+
+To avoid data loss, you must not run borg check --repair using an unfixed version
+of borg 1.1.x. The first official release that has the fix is 1.1.4.
+
+Package maintainers may have applied the fix to updated packages of 1.1.x (x<4)
+though, see the package maintainer's package changelog to make sure.
+
+If you never had missing item metadata chunks, the bug has not affected you
+even if you did run borg check --repair with an unfixed version.
+
+When borg check --repair tried to repair corrupt archives that miss item metadata
+chunks, the resync to valid metadata in still present item metadata chunks
+malfunctioned. This was due to a broken validator that considered all (even valid)
+item metadata as invalid. As they were considered invalid, borg discarded them.
+Practically, that means the affected files, directories or other fs objects were
+discarded from the archive.
+
+Due to the malfunction, the process was extremely slow, but if you let it
+complete, borg would have created a "repaired" archive that has lost a lot of items.
+If you interrupted borg check --repair because it was so strangely slow (killing
+borg somehow, e.g. Ctrl-C) the transaction was rolled back and no corruption occurred.
+
+The log message indicating the precondition for the bug triggering looks like:
+
+    item metadata chunk missing [chunk: 001056_bdee87d...a3e50d]
+
+If you never had that in your borg check --repair runs, you're not affected.
+
+But if you're unsure or you actually have seen that, better check your archives.
+By just using "borg list repo::archive" you can see if all expected filesystem
+items are listed.
+
+.. _tam_vuln:
+
+Pre-1.0.9 manifest spoofing vulnerability (CVE-2016-10099)
+----------------------------------------------------------
+
+A flaw in the cryptographic authentication scheme in Borg allowed an attacker
+to spoof the manifest. The attack requires an attacker to be able to
+
+1. insert files (with no additional headers) into backups
+2. gain write access to the repository
+
+This vulnerability does not disclose plaintext to the attacker, nor does it
+affect the authenticity of existing archives.
+
+The vulnerability allows an attacker to create a spoofed manifest (the list of archives).
+Creating plausible fake archives may be feasible for small archives, but is unlikely
+for large archives.
+
+The fix adds a separate authentication tag to the manifest. For compatibility
+with prior versions this authentication tag is *not* required by default
+for existing repositories. Repositories created with 1.0.9 and later require it.
+
+Steps you should take:
+
+1. Upgrade all clients to 1.0.9 or later.
+2. Run ``borg upgrade --tam <repository>`` *on every client* for *each* repository.
+3. This will list all archives, including archive IDs, for easy comparison with your logs.
+4. Done.
+
+Prior versions can access and modify repositories with this measure enabled, however,
+to 1.0.9 or later their modifications are indiscernible from an attack and will
+raise an error until the below procedure is followed. We are aware that this can
+be annoying in some circumstances, but don't see a way to fix the vulnerability
+otherwise.
+
+In case a version prior to 1.0.9 is used to modify a repository where above procedure
+was completed, and now you get an error message from other clients:
+
+1. ``borg upgrade --tam --force <repository>`` once with *any* client suffices.
+
+This attack is mitigated by:
+
+- Noting/logging ``borg list``, ``borg info``, or ``borg create --stats``, which
+  contain the archive IDs.
+
+We are not aware of others having discovered, disclosed or exploited this vulnerability.
+
+Vulnerability time line:
+
+* 2016-11-14: Vulnerability and fix discovered during review of cryptography by Marian Beermann (@enkore)
+* 2016-11-20: First patch
+* 2016-12-20: Released fixed version 1.0.9
+* 2017-01-02: CVE was assigned
+* 2017-01-15: Released fixed version 1.1.0b3 (fix was previously only available from source)
+
+.. _attic013_check_corruption:
+
+Pre-1.0.9 potential data loss
+-----------------------------
+
+If you have archives in your repository that were made with attic <= 0.13
+(and later migrated to borg), running borg check would report errors in these
+archives. See issue #1837.
+
+The reason for this is a invalid (and useless) metadata key that was
+always added due to a bug in these old attic versions.
+
+If you run borg check --repair, things escalate quickly: all archive items
+with invalid metadata will be killed. Due to that attic bug, that means all
+items in all archives made with these old attic versions.
+
+
+Pre-1.0.4 potential repo corruption
+-----------------------------------
+
+Some external errors (like network or disk I/O errors) could lead to
+corruption of the backup repository due to issue #1138.
+
+A sign that this happened is if "E" status was reported for a file that can
+not be explained by problems with the source file. If you still have logs from
+"borg create -v --list", you can check for "E" status.
+
+Here is what could cause corruption and what you can do now:
+
+1) I/O errors (e.g. repo disk errors) while writing data to repo.
+
+This could lead to corrupted segment files.
+
+Fix::
+
+    # check for corrupt chunks / segments:
+    borg check -v --repository-only REPO
+
+    # repair the repo:
+    borg check -v --repository-only --repair REPO
+
+    # make sure everything is fixed:
+    borg check -v --repository-only REPO
+
+2) Unreliable network / unreliable connection to the repo.
+
+This could lead to archive metadata corruption.
+
+Fix::
+
+    # check for corrupt archives:
+    borg check -v --archives-only REPO
+
+    # delete the corrupt archives:
+    borg delete --force REPO::CORRUPT_ARCHIVE
+
+    # make sure everything is fixed:
+    borg check -v --archives-only REPO
+
+3) In case you want to do more intensive checking.
+
+The best check that everything is ok is to run a dry-run extraction::
+
+    borg extract -v --dry-run REPO::ARCHIVE
+
+.. _changelog_1x:
+
+Change Log 1.x
+==============
+
+Version 1.3.0a1 (2022-04-15)
+----------------------------
+
+Please note:
+
+This is an alpha release, only for testing - do not use this with production repos.
+
+New features:
+
+- init: new --encryption=(repokey|keyfile)-[blake2-](aes-ocb|chacha20-poly1305)
+
+  - New, better, faster crypto (see encryption-aead diagram in the docs), #6463.
+  - New AEAD cipher suites: AES-OCB and CHACHA20-POLY1305.
+  - Session keys are derived via HKDF from random session id and master key.
+  - Nonces/MessageIVs are counters starting from 0 for each session.
+  - AAD: chunk id, key type, messageIV, sessionID are now authenticated also.
+  - Solves the potential AES-CTR mode counter management issues of the legacy crypto.
+- init: --key-algorithm=argon2 (new default KDF, older pbkdf2 also still available)
+
+  borg key change-passphrase / change-location keeps the key algorithm unchanged.
+- key change-algorithm: to upgrade existing keys to argon2 or downgrade to pbkdf2.
+
+  We recommend you to upgrade unless you have to keep the key compatible with older versions of borg.
+- key change-location: usable for repokey <-> keyfile location change
+- benchmark cpu: display benchmarks of cpu bound stuff
+- export-tar: new --tar-format=PAX (default: GNU)
+- import-tar/export-tar: can use PAX format for ctime and atime support
+- import-tar/export-tar: --tar-format=BORG: roundtrip ALL item metadata, #5830
+- repository: create and use version 2 repos only for now
+- repository: implement PUT2: header crc32, overall xxh64, #1704
+
+Other changes:
+
+- require python >= 3.9, #6315
+- simplify libs setup, #6482
+- unbundle most bundled 3rd party code, use libs, #6316
+- use libdeflate.crc32 (Linux and all others) or zlib.crc32 (macOS)
+- repository: code cleanups / simplifications
+- internal crypto api: speedups / cleanups / refactorings / modernisation
+- remove "borg upgrade" support for "attic backup" repos
+- remove PassphraseKey code and borg key migrate-to-repokey command
+- OpenBSD: build borg with OpenSSL (not: LibreSSL), #6474
+- remove support for LibreSSL, #6474
+- remove support for OpenSSL < 1.1.1
+
+
+Version 1.2.0 (2022-02-22 22:02:22 :-)
+--------------------------------------
+
+Please note:
+
+This is the first borg 1.2 release, so be careful and read the notes below.
+
+Upgrade notes:
+
+Strictly taken, nothing special is required for upgrading to 1.2, but some
+things can be recommended:
+
+- do you already want to upgrade? 1.1.x also will get fixes for a while.
+- be careful, first upgrade your less critical / smaller repos.
+- first upgrade to a recent 1.1.x release - especially if you run some older
+  1.1.* or even 1.0.* borg release.
+- using that, run at least one `borg create` (your normal backup), `prune`
+  and especially a `check` to see everything is in a good state.
+- check the output of `borg check` - if there is anything special, consider
+  a `borg check --repair` followed by another `borg check`.
+- if everything is fine so far (borg check reports no issues), you can consider
+  upgrading to 1.2.0. if not, please first fix any already existing issue.
+- if you want to play safer, first **create a backup of your borg repository**.
+- upgrade to latest borg 1.2.x release (you could use the fat binary from
+  github releases page)
+- run `borg compact --cleanup-commits` to clean up a ton of 17 bytes long files
+  in your repo caused by a borg 1.1 bug
+- run `borg check` again (now with borg 1.2.x) and check if there is anything
+  special.
+- run `borg info` (with borg 1.2.x) to build the local pre12-meta cache (can
+  take significant time, but after that it will be fast) - for more details
+  see below.
+- check the compatibility notes (see below) and adapt your scripts, if needed.
+- if you run into any issues, please check the github issue tracker before
+  posting new issues there or elsewhere.
+
+If you follow this procedure, you can help avoiding that we get a lot of
+"borg 1.2" issue reports that are not really 1.2 issues, but existed before
+and maybe just were not noticed.
+
+Compatibility notes:
+
+- matching of path patterns has been aligned with borg storing relative paths.
+  Borg archives file paths without leading slashes. Previously, include/exclude
+  patterns could contain leading slashes. You should check your patterns and
+  remove leading slashes.
+- dropped support / testing for older Pythons, minimum requirement is 3.8.
+  In case your OS does not provide Python >= 3.8, consider using our binary,
+  which does not need an external Python interpreter. Or continue using
+  borg 1.1.x, which is still supported.
+- freeing repository space only happens when "borg compact" is invoked.
+- mount: the default for --numeric-ids is False now (same as borg extract)
+- borg create --noatime is deprecated. Not storing atime is the default behaviour
+  now (use --atime if you want to store the atime).
+- list: corrected mix-up of "isomtime" and "mtime" formats.
+  Previously, "isomtime" was the default but produced a verbose human format,
+  while "mtime" produced a ISO-8601-like format.
+  The behaviours have been swapped (so "mtime" is human, "isomtime" is ISO-like),
+  and the default is now "mtime".
+  "isomtime" is now a real ISO-8601 format ("T" between date and time, not a space).
+- create/recreate --list: file status for all files used to get announced *AFTER*
+  the file (with borg < 1.2). Now, file status is announced *BEFORE* the file
+  contents are processed. If the file status changes later (e.g. due to an error
+  or a content change), the updated/final file status will be printed again.
+- removed deprecated-since-long stuff (deprecated since):
+
+  - command "borg change-passphrase" (2017-02), use "borg key ..."
+  - option "--keep-tag-files" (2017-01), use "--keep-exclude-tags"
+  - option "--list-format" (2017-10), use "--format"
+  - option "--ignore-inode" (2017-09), use "--files-cache" w/o "inode"
+  - option "--no-files-cache" (2017-09), use "--files-cache=disabled"
+- removed BORG_HOSTNAME_IS_UNIQUE env var.
+  to use borg you must implement one of these 2 scenarios:
+
+  - 1) the combination of FQDN and result of uuid.getnode() must be unique
+       and stable (this should be the case for almost everybody, except when
+       having duplicate FQDN *and* MAC address or all-zero MAC address)
+  - 2) if you are aware that 1) is not the case for you, you must set
+       BORG_HOST_ID env var to something unique.
+- exit with 128 + signal number, #5161.
+  if you have scripts expecting rc == 2 for a signal exit, you need to update
+  them to check for >= 128.
+
+Fixes:
+
+- diff: reduce memory consumption, fix is_hardlink_master, #6295
+- compact: fix / improve freeable / freed space log output
+
+  - derive really freed space from quota use before/after, #5679
+  - do not say "freeable", but "maybe freeable" (based on hint, unsure)
+- fix race conditions in internal SaveFile function, #6306 #6028
+- implement internal safe_unlink (was: truncate_and_unlink) function more safely:
+  usually it does not truncate any more, only under "disk full" circumstances
+  and only if there is only one hardlink.
+  see: https://github.com/borgbackup/borg/discussions/6286
+
+Other changes:
+
+- info: use a pre12-meta cache to accelerate stats for borg < 1.2 archives.
+  the first time borg info is invoked on a borg 1.1 repo, it can take a
+  rather long time computing and caching some stats values for 1.1 archives,
+  which borg 1.2 archives have in their archive metadata structure.
+  be patient, esp. if you have lots of old archives.
+  following invocations are much faster due to the cache.
+  related change: add archive name to calc_stats progress display.
+- docs:
+
+  - add borg 1.2 upgrade notes, #6217
+  - link to borg placeholders and borg patterns help
+  - init: explain the encryption modes better
+  - clarify usage of patternfile roots
+  - put import-tar docs into same file as export-tar docs
+  - explain the difference between a path that ends with or without a slash,
+    #6297
+
+
+Version 1.2.0rc1 (2022-02-05)
+-----------------------------
+
+Fixes:
+
+- repo::archive location placeholder expansion fixes, #5826, #5998
+- repository: fix intermediate commits, shall be at end of current segment
+- delete: don't commit if nothing was deleted, avoid cache sync, #6060
+- argument parsing: accept some options only once, #6026
+- disallow overwriting of existing keyfiles on init, #6036
+- if ensure_dir() fails, give more informative error message, #5952
+
+New features:
+
+- delete --force: do not ask when deleting a repo, #5941
+
+Other changes:
+
+- requirements: exclude broken or incompatible-with-pyinstaller setuptools
+- add a requirements.d/development.lock.txt and use it for vagrant
+- tests:
+
+  - added nonce-related tests
+  - refactor: remove assert_true
+  - vagrant: macos box tuning, netbsd box fixes, #5370, #5922
+- docs:
+
+  - update install docs / requirements docs, #6180
+  - borg mount / FUSE "versions" view is not experimental any more
+  - --pattern* is not experimental any more, #6134
+  - impact of deleting path/to/repo/nonce, #5858
+  - key export: add examples, #6204
+  - ~/.config/borg/keys is not used for repokey keys, #6107
+  - excluded parent dir's metadata can't restore
+
+
+Version 1.2.0b4 (2022-01-23)
+----------------------------
+
+Fixes:
+
+- create: fix passing device nodes and symlinks to --paths-from-stdin, #6009
+- create --dry-run: fix display of kept tagfile, #5834
+- check --repair: fix missing parameter in "did not consistently fail" msg, #5822
+- fix hardlinkable file type check, #6037
+- list: remove placeholders for shake_* hashes, #6082
+- prune: handle case of calling prune_split when there are no archives, #6015
+- benchmark crud: make sure cleanup of borg-test-data files/dir happens, #5630
+- do not show archive name in repository-related error msgs, #6014
+- prettier error msg (no stacktrace) if exclude file is missing, #5734
+- do not require BORG_CONFIG_DIR if BORG_{SECURITY,KEYS}_DIR are set, #5979
+- fix pyinstaller detection for dir-mode, #5897
+- atomically create the CACHE_TAG file, #6028
+- deal with the SaveFile/SyncFile race, docs, see #6056 708a5853
+- avoid expanding path into LHS of formatting operation + tests, #6064 #6063
+- repository: quota / compactable computation fixes
+- info: emit repo info even if repo has 0 archives + test, #6120
+
+New features:
+
+- check --repair: significantly speed up search for next valid object in segment, #6022
+- check: add progress indicator for archive check, #5809
+- create: add retry_erofs workaround for O_NOATIME issue on volume shadow copies in WSL1, #6024
+- create: allow --files-cache=size (this is potentially dangerous, use on your own risk), #5686
+- import-tar: implement import-tar to complement export-tar, #2233
+- implement BORG_SELFTEST env variable (can be carefully used to speedup borg hosting), #5871
+- key export: print key if path is '-' or not given, #6092
+- list --format: Add command_line to format keys
+
+Other changes:
+
+- pypi metadata: alpha -> beta
+- require python 3.8+, #5975
+- use pyinstaller 4.7
+- allow msgpack 1.0.3
+- upgrade to bundled xxhash to 0.8.1
+- import-tar / export-tar: tar file related changes:
+
+  - check for short tarfile extensions
+  - add .lz4 and .zstd
+  - fix docs about extensions and decompression commands
+- add github codeql analysis, #6148
+- vagrant:
+
+  - box updates / add new boxes / remove outdated and broken boxes
+  - use Python 3.9.10 (incl. binary builds) and 3.10.0
+  - fix pyenv initialisation, #5798
+  - fix vagrant scp on macOS, #5921
+  - use macfuse instead of osxfuse
+- shell completions:
+
+  - update shell completions to 1.1.17, #5923
+  - remove BORG_LIBC completion, since 9914968 borg no longer uses find_library().
+- docs:
+
+  - fixed readme.rst irc webchat link (we use libera chat now, not freenode)
+  - fix exceptions thrown by `setup.py build_man`
+  - check --repair: recommend checking hw before check --repair, #5855
+  - check --verify-data: clarify and document conflict with --repository-only, #5808
+  - serve: improve ssh forced commands docs, #6083
+  - list: improve docs for `borg list` --format, #6061
+  - list: remove --list-format from borg list
+  - FAQ: fix manifest-timestamp path (inside security dir)
+  - fix the broken link to .nix file
+  - document behavior for filesystems with inconsistent inodes, #5770
+  - clarify user_id vs uid for fuse, #5723
+  - clarify pattern usage with commands, #5176
+  - clarify pp vs. pf pattern type, #5300
+  - update referenced freebsd/macOS versions used for binary build, #5942
+  - pull mode: add some warnings, #5827
+  - clarify "you will need key and passphrase" borg init warning, #4622
+  - add missing leading slashes in help patterns, #5857
+  - add info on renaming repositories, #5240
+  - check: add notice about defective hardware, #5753
+  - mention tar --compare (compare archive to fs files), #5880
+  - add note about grandfather-father-son backup retention policy / rotation scheme, #6006
+  - permissions note rewritten to make it less confusing
+  - create github security policy
+  - remove leftovers of BORG_HOSTNAME_IS_UNIQUE
+  - excluded parent dir's metadata can't restore. (#6062)
+  - if parent dir is not extracted, we do not have its metadata
+  - clarify who starts the remote agent
+
+
+Version 1.2.0b3 (2021-05-12)
+----------------------------
+
+Fixes:
+
+- create: fix --progress --log-json, #4360#issuecomment-774580052
+- do not load files cache for commands not using it, #5673
+- fix repeated cache tag file writing bug
+
+New features:
+
+- create/recreate: print preliminary file status early, #5417
+- create/extract: add --noxattrs and --noacls options, #3955
+- create: verbose files cache logging via --debug-topic=files_cache, #5659
+- mount: implement --numeric-ids (default: False!), #2377
+- diff: add --json-lines option
+- info / create --stats: add --iec option to print sizes in powers of 1024.
+
+Other changes:
+
+- create: add --upload-(ratelimit|buffer), deprecate --remote-* options, #5611
+- create/extract/mount: add --numeric-ids, deprecate --numeric-owner option, #5724
+- config: accept non-int value for max_segment_size / storage_quota
+- use PyInstaller v4.3, #5671
+- vagrant: use Python 3.9.5 to build binaries
+- tox.ini: modernize and enable execution without preinstalling deps
+- cleanup code style checks
+- get rid of distutils, use setuptools+packaging
+- github CI: test on Python 3.10-dev
+- check: missing / healed chunks: always tell chunk ID, #5704
+- docs:
+
+  - remove bad /var/cache exclusion in example commands, #5625
+  - misc. fixes and improvements, esp. for macOS
+  - add unsafe workaround to use an old repo copy, #5722
+
+
+Version 1.2.0b2 (2021-02-06)
+----------------------------
+
+Fixes:
+
+- create: do not recurse into duplicate roots, #5603
+- create: only print stats if not ctrl-c'ed, fixes traceback, #5668
+- extract:
+  improve exception handling when setting xattrs, #5092.
+  emit a warning message giving the path, xattr key and error message.
+  continue trying to restore other xattrs and bsdflags of the same file
+  after an exception with xattr-setting happened.
+- export-tar:
+  fix memory leak with ssh: remote repository, #5568.
+  fix potential memory leak with ssh: remote repository with partial extraction.
+- remove empty shadowed_segments lists, #5275
+- fix bad default: manifest.archives.list(consider_checkpoints=False),
+  fixes tracebacks / KeyErros for missing objects in ChunkIndex, #5668
+
+New features:
+
+- create: improve sparse file support
+
+  - create --sparse (detect sparse file holes) and file map support,
+    only for the "fixed" chunker, #14
+  - detect all-zero chunks in read data in "buzhash" and "fixed" chunkers
+  - cached_hash: use a small LRU cache to accelerate all-zero chunks hashing
+  - use cached_hash also to generate all-zero replacement chunks
+- create --remote-buffer, add a upload buffer for remote repos, #5574
+- prune: keep oldest archive when retention target not met
+
+Other changes:
+
+- use blake2 from python 3.6+ hashlib
+  (this removes the requirement for libb2 and the bundled blake2 code)
+- also accept msgpack up to 1.0.2.
+  exclude 1.0.1 though, which had some issues (not sure they affect borg).
+- create: add repository location to --stats output, #5491
+- check: debug log the segment filename
+- delete: add a --list switch to borg delete, #5116
+- borg debug dump-hints - implemented to e.g. to look at shadow_index
+- Tab completion support for additional archives for 'borg delete'
+- refactor: have one borg.constants.zero all-zero bytes object
+- refactor shadow_index updating repo.put/delete, #5661, #5636.
+- docs:
+
+  - add another case of attempted hardlink usage
+  - fix description of borg upgrade hardlink usage, #5518
+  - use HTTPS everywhere
+  - add examples for --paths-from-stdin, --paths-from-command, --paths-separator, #5644
+  - fix typos/grammar
+  - update docs for dev environment installation instructions
+  - recommend running tests only on installed versions for setup
+  - add badge with current status of package
+- vagrant:
+
+  - use brew install --cask ..., #5557
+  - use Python 3.9.1 and PyInstaller 4.1 to build the borg binary
+
+
+Version 1.2.0b1 (2020-12-06)
+----------------------------
+
+Fixes:
+
+- BORG_CACHE_DIR crashing borg if empty, atomic handling of
+  recursive directory creation, #5216
+- fix --dry-run and --stats coexistence, #5415
+- allow EIO with warning when trying to hardlink, #4336
+- export-tar: set tar format to GNU_FORMAT explicitly, #5274
+- use --timestamp for {utcnow} and {now} if given, #5189
+- make timestamp helper timezone-aware
+
+New features:
+
+- create: implement --paths-from-stdin and --paths-from-command, see #5492.
+  These switches read paths to archive from stdin. Delimiter can specified
+  by --paths-delimiter=DELIM. Paths read will be added honoring every
+  option but exclusion options and --one-file-system. borg won't recurse
+  into directories.
+- 'obfuscate' pseudo compressor obfuscates compressed chunk size in repo
+- add pyfuse3 (successor of llfuse) as an alternative lowlevel fuse
+  implementation to llfuse (deprecated), #5407.
+  FUSE implementation can be switched via env var BORG_FUSE_IMPL.
+- allow appending to the files cache filename with BORG_FILES_CACHE_SUFFIX
+- create: implement --stdin-mode, --stdin-user and --stdin-group, #5333
+
+Other changes:
+
+- split recursive directory walking/processing into directory walking and
+  item processing.
+- fix warning by importing setuptools before distutils.
+- debug info: include infos about FUSE implementation, #5546
+- testing:
+
+  - add a test for the hashindex corruption bug, #5531 #4829
+  - move away from travis-ci, use github actions, #5528 #5467
+  - test both on fuse2 and fuse3
+  - upload coverage reports to codecov
+  - fix spurious failure in test_cache_files, #5438
+  - add tests for Location.with_timestamp
+  - tox: add a non-fuse env to the envlist
+- vagrant:
+
+  - use python 3.7.latest and pyinstaller 4.0 for binary creation
+  - pyinstaller: compute basepath from spec file location
+  - vagrant: updates/fixes for archlinux box, #5543
+- docs:
+
+  - "filename with spaces" example added to exclude file, #5236
+  - add a hint about sleeping computer, #5301
+  - how to adjust macOS >= Catalina security settings, #5303
+  - process/policy for adding new compression algorithms
+  - updated docs about hacked backup client, #5480
+  - improve ansible deployment docs, make it more generic
+  - how to approach borg speed issues, give speed example, #5371
+  - fix mathematical inaccuracy about chunk size, #5336
+  - add example for excluding content using --pattern cli option
+  - clarify borg create's '--one-file-system' option, #4009
+  - improve docs/FAQ about append-only remote repos, #5497
+  - fix reST markup issues, labels
+  - add infos about contributor retirement status
+
+
+Version 1.2.0a9 (2020-10-05)
+----------------------------
+
+Fixes:
+
+- fix memory leak related to preloading, #5202
+- check --repair: fix potential data loss, #5325
+- persist shadow_index in between borg runs, #4830
+- fix hardlinked CACHEDIR.TAG processing, #4911
+- --read-special: .part files also should be regular files, #5217
+- allow server side enforcing of umask, --umask is for the local borg
+  process only (see docs), #4947
+- exit with 128 + signal number, #5161
+- borg config --list does not show last_segment_checked, #5159
+- locking:
+
+  - fix ExclusiveLock race condition bug, #4923
+  - fix race condition in lock migration, #4953
+  - fix locking on openindiana, #5271
+
+New features:
+
+- --content-from-command: create archive using stdout of given command, #5174
+- allow key-import + BORG_KEY_FILE to create key files
+- build directory-based binary for macOS to avoid Gatekeeper delays
+
+Other changes:
+
+- upgrade bundled zstd to 1.4.5
+- upgrade bundled xxhash to 0.8.0, #5362
+- if self test fails, also point to OS and hardware, #5334
+- misc. shell completions fixes/updates, rewrite zsh completion
+- prettier error message when archive gets too big, #5307
+- stop relying on `false` exiting with status code 1
+- rephrase some warnings, #5164
+- parseformat: unnecessary calls removed, #5169
+- testing:
+
+  - enable Python3.9 env for test suite and VMs, #5373
+  - drop python 3.5, #5344
+  - misc. vagrant fixes/updates
+  - misc. testing fixes, #5196
+- docs:
+
+  - add ssh-agent pull backup method to doc, #5288
+  - mention double --force in prune docs
+  - update Homebrew install instructions, #5185
+  - better description of how cache and rebuilds of it work
+    and how the workaround applies to that
+  - point to borg create --list item flags in recreate usage, #5165
+  - add a note to create from stdin regarding files cache, #5180
+  - add security faq explaining AES-CTR crypto issues, #5254
+  - clarify --exclude-if-present in recreate, #5193
+  - add socat pull mode, #5150, #900
+  - move content of resources doc page to community project, #2088
+  - explain hash collision, #4884
+  - clarify --recompress option, #5154
+
+
+Version 1.2.0a8 (2020-04-22)
+----------------------------
+
+Fixes:
+
+- fixed potential index corruption / data loss issue due to bug in hashindex_set, #4829.
+  Please read and follow the more detailed notes close to the top of this document.
+- fix crash when upgrading erroneous hints file, #4922
+- commit-time free space calc: ignore bad compact map entries, #4796
+- info: if the archive doesn't exist, print a pretty message, #4793
+- --prefix / -P: fix processing, avoid argparse issue, #4769
+- ignore EACCES (errno 13) when hardlinking, #4730
+- add a try catch when formatting the info string, #4818
+- check: do not stumble over invalid item key, #4845
+- update prevalence of env vars to set config and cache paths
+- mount: fix FUSE low linear read speed on large files, #5032
+- extract: fix confusing output of borg extract --list --strip-components, #4934
+- recreate: support --timestamp option, #4745
+- fix ProgressIndicator msgids (JSON output), #4935
+- fuse: set f_namemax in statfs result, #2684
+- accept absolute paths on windows
+- pyinstaller: work around issue with setuptools > 44
+
+New features:
+
+- chunker speedup (plus regression test)
+- added --consider-checkpoints and related test, #4788
+- added --noflags option, deprecate --nobsdflags option, #4489
+- compact: add --threshold option, #4674
+- mount: add birthtime to FUSE entries
+- support platforms with no os.link, #4901 - if we don't have os.link,
+  we just extract another copy instead of making a hardlink.
+- move sync_file_range to its own extension for better platform compatibility.
+- new --bypass-lock option to bypass locking, e.g. for read-only repos
+- accept absolute paths by removing leading slashes in patterns of all
+  sorts but re: style, #4029
+- delete: new --keep-security-info option
+
+Other changes:
+
+- support msgpack 0.6.2 and 1.0.0, #5065
+- upgrade bundled zstd to 1.4.4
+- upgrade bundled lz4 to 1.9.2
+- upgrade xxhash to 0.7.3
+- require recent enough llfuse for birthtime support, #5064
+- only store compressed data if the result actually is smaller, #4516
+- check: improve error output for matching index size, see #4829
+- ignore --stats when given with --dry-run, but continue, #4373
+- replaced usage of os.statvfs with shutil.disk_usage (better cross-platform support).
+- fuse: remove unneeded version check and compat code, micro opts
+- docs:
+
+  - improve description of path variables
+  - document how to completely delete data, #2929
+  - add FAQ about Borg config dir, #4941
+  - add docs about errors not printed as JSON, #4073
+  - update usage_general.rst.inc
+  - added "Will move with BORG_CONFIG_DIR variable unless specified." to BORG_SECURITY_DIR info.
+  - put BORG_SECURITY_DIR immediately below BORG_CONFIG_DIR (and moved BORG_CACHE_DIR up before them).
+  - add paragraph regarding cache security assumptions, #4900
+  - tell about borg cache security precautions
+  - add FAQ describing difference between a local repo vs. repo on a server.
+  - document how to test exclusion patterns without performing an actual backup
+  - create: tell that "Calculating size" time and space needs are caused by --progress
+  - fix/improve documentation for @api decorator, #4674
+  - add a pull backup / push restore how-to, #1552
+  - fix man pages creation, #4752
+  - more general FAQ for backup and retain original paths, #4532
+  - explain difference between --exclude and --pattern, #4118
+  - add FAQ for preventing SSH timeout in extract, #3866
+  - improve password FAQ (decrease pw length, add -w 0 option to base64 to prevent line wrap), #4591
+  - add note about patterns and stored paths, #4160
+  - add upgrade of tools to pip installation how-to, #5090
+  - document one cause of orphaned chunks in check command, #2295
+  - clean up the whole check usage paragraph
+  - FAQ: linked recommended restrictions to ssh public keys on borg servers, #4946
+  - fixed "doc downplays severity of Nonce reuse issue", #4883
+  - borg repo restore instructions needed, #3428
+  - new FAQ: A repo is corrupt and must be replaced with an older repo.
+  - clarify borg init's encryption modes
+- native windows port:
+
+  - update README_WINDOWS.rst
+  - updated pyinstaller spec file to support windows builds
+- testing / CI:
+
+  - improved travis config / install script, improved macOS builds
+  - allow osx builds to fail, #4955
+  - Windows 10 build on Appveyor CI
+- vagrant:
+
+  - upgrade pyinstaller to v3.5 + patch
+  - use py369 for binary build, add py380 for tests
+  - fix issue in stretch VM hanging at grub installation
+  - add a debian buster and a ubuntu focal VM
+  - update darwin box to 10.12
+  - upgrade FreeBSD box to 12.1
+  - fix debianoid virtualenv packages
+  - use pyenv in freebsd64 VM
+  - remove the flake8 test
+  - darwin: avoid error if pkg is already installed
+  - debianoid: don't interactively ask questions
+
+
+Version 1.2.0a7 (2019-09-07)
+----------------------------
+
+Fixes:
+
+- slave hardlinks extraction issue, see #4350
+- extract: fix KeyError for "partial" extraction, #4607
+- preload chunks for hardlink slaves w/o preloaded master, #4350
+- fix preloading for old remote servers, #4652
+- fix partial extract for hardlinked contentless file types, #4725
+- Repository.open: use stat() to check for repo dir, #4695
+- Repository.check_can_create_repository: use stat() to check, ~ #4695.
+- SecurityManager.known(): check all files, #4614
+- after double-force delete, warn about necessary repair, #4704
+- cope with ANY error when importing pytest into borg.testsuite, #4652
+- fix invalid archive error message
+- setup.py: fix detection of missing Cython
+- filter out selinux xattrs, #4574
+- location arg - should it be optional? #4541
+- enable placeholder usage in --comment, #4559
+- use whitelist approach for borg serve, #4097
+
+New features:
+
+- minimal native Windows support, see windows readme (work in progress)
+- create: first ctrl-c (SIGINT) triggers checkpoint and abort, #4606
+- new BORG_WORKAROUNDS mechanism, basesyncfile, #4710
+- remove WSL autodetection. if WSL still has this problem, you need to
+  set BORG_WORKAROUNDS=basesyncfile in the borg process environment to
+  work around it.
+- support xxh64 checksum in addition to the hashlib hashes in borg list
+- enable placeholder usage in all extra archive arguments
+- enable placeholder usage in --comment, #4559
+- enable placeholder usage in --glob-archives, #4495
+- ability to use a system-provided version of "xxhash"
+- create:
+
+  - changed the default behaviour to not store the atime of fs items. atime is
+    often rather not interesting and fragile - it easily changes even if nothing
+    else has changed and, if stored into the archive, spoils deduplication of
+    the archive metadata stream.
+  - if you give the --noatime option, borg will output a deprecation warning
+    because it is currently ignored / does nothing.
+    Please remove the --noatime option when using borg 1.2.
+  - added a --atime option for storing files' atime into an archive
+
+Other changes:
+
+- argparser: always use REPOSITORY in metavar
+- do not check python/libc for borg serve, #4483
+- small borg compact improvements, #4522
+- compact: log freed space at INFO level
+- tests:
+
+  - tox / travis: add testing on py38-dev
+  - fix broken test that relied on improper zlib assumptions
+  - pure-py msgpack warning shall not make a lot of tests fail, #4558
+  - rename test_mount_hardlinks to test_fuse_mount_hardlinks (master)
+  - vagrant: add up-to-date openindiana box (py35, openssl10)
+  - get rid of confusing coverage warning, #2069
+- docs:
+
+  - reiterate that 'file cache names are absolute' in FAQ,
+    mention bind mount solution, #4738
+  - add restore docs, #4670
+  - updated docs to cover use of temp directory on remote, #4545
+  - add a push-style example to borg-create(1), #4613
+  - timestamps in the files cache are now usually ctime, #4583
+  - benchmark crud: clarify that space is used until compact
+  - update documentation of borg create,
+    corrects a mention of borg 1.1 as a future version.
+  - fix osxfuse github link in installation docs
+  - how to supply a passphrase, use crypto devices, #4549
+  - extract: document limitation "needs empty destination",  #4598
+  - update macOS Brew link
+  - add note about software for automating backup
+  - compact: improve docs,
+  - README: new URL for funding options
+
+
+Version 1.2.0a6 (2019-04-22)
+----------------------------
+
+Fixes:
+
+- delete / prune: consider part files correctly for stats, #4507
+- fix "all archives" stats considering part files, #4329
+- create: only run stat_simple_attrs() once
+- create: --stats does not work with --dry-run, exit with error msg, #4373
+- give "invalid repo" error msg if repo config not found, #4411
+
+New features:
+
+- display msgpack version as part of sysinfo (e.g. in tracebacks)
+
+Other changes:
+
+- docs:
+
+  - sdd "SSH Configuration" section, #4493, #3988, #636, #4485
+  - better document borg check --max-duration, #4473
+  - sorted commands help in multiple steps, #4471
+- testing:
+
+  - travis: use py 3.5.3 and 3.6.7 on macOS to get a pyenv-based python
+    build with openssl 1.1
+  - vagrant: use py 3.5.3 and 3.6.8 on darwin64 VM to build python and
+    borg with openssl 1.1
+  - pytest: -v and default XDISTN to 1, #4481
+
+
+Version 1.2.0a5 (2019-03-21)
+----------------------------
+
+Fixes:
+
+- warn if a file has changed while being backed up, #1750
+- lrucache: regularly remove old FDs, #4427
+- borg command shall terminate with rc 2 for ImportErrors, #4424
+- make freebsd xattr platform code api compatible with linux, #3952
+
+Other changes:
+
+- major setup code refactoring (especially how libraries like openssl, liblz4,
+  libzstd, libb2 are discovered and how it falls back to code bundled with
+  borg), new: uses pkg-config now (and needs python "pkgconfig" package
+  installed), #1925
+
+  if you are a borg package maintainer, please try packaging this
+  (see comments in setup.py).
+- Vagrantfile: add zstd, reorder, build env vars, #4444
+- travis: install script improvements
+- update shell completions
+- docs:
+
+  - add a sample logging.conf in docs/misc, #4380
+  - fix spelling errors
+  - update requirements / install docs, #4374
+
+
+Version 1.2.0a4 (2019-03-11)
+----------------------------
+
+Fixes:
+
+- do not use O_NONBLOCK for special files, like FIFOs, block and char devices
+  when using --read-special. fixes backing up FIFOs. fixes to test. #4394
+- more LibreSSL build fixes: LibreSSL has HMAC_CTX_free and HMAC_CTX_new
+
+New features:
+
+- check: incremental repo check (only checks crc32 for segment entries), #1657
+  borg check --repository-only --max-duration SECONDS ...
+- delete: timestamp for borg delete --info added, #4359
+
+Other changes:
+
+- redo stale lock handling, #3986
+  drop BORG_HOSTNAME_IS_UNIQUE (please use BORG_HOST_ID if needed).
+  borg now always assumes it has a unique host id - either automatically
+  from fqdn plus uuid.getnode() or overridden via BORG_HOST_ID.
+- docs:
+
+  - added Alpine Linux to distribution list
+  - elaborate on append-only mode docs
+- vagrant:
+
+  - darwin: new 10.12 box
+  - freebsd: new 12.0 box
+  - openbsd: new 6.4 box
+  - misc. updates / fixes
+
+
+Version 1.2.0a3 (2019-02-26)
+----------------------------
+
+Fixes:
+
+- LibreSSL build fixes, #4403
+- dummy ACL/xattr code fixes (used by OpenBSD and others), #4403
+- create: fix openat/statat issues for root directory, #4405
+
+
+Version 1.2.0a2 and earlier (2019-02-24)
+----------------------------------------
+
+New features:
+
+- compact: "borg compact" needs to be used to free repository space by
+  compacting the segments (reading sparse segments, rewriting still needed
+  data to new segments, deleting the sparse segments).
+  Borg < 1.2 invoked compaction automatically at the end of each repository
+  writing command.
+  Borg >= 1.2 does not do that any more to give better speed, more control,
+  more segment file stability (== less stuff moving to newer segments) and
+  more robustness.
+  See the docs about "borg compact" for more details.
+- "borg compact --cleanup-commits" is to cleanup the tons of 17byte long
+  commit-only segment files caused by borg 1.1.x issue #2850.
+  Invoke this once after upgrading (the server side) borg to 1.2.
+  Compaction now automatically removes unneeded commit-only segment files.
+- prune: Show which rule was applied to keep archive, #2886
+- add fixed blocksize chunker (see --chunker-params docs), #1086
+
+Fixes:
+
+- avoid stale filehandle issues, #3265
+- use more FDs, avoid race conditions on active fs, #906, #908, #1038
+- add O_NOFOLLOW to base flags, #908
+- compact:
+
+  - require >10% freeable space in a segment, #2985
+  - repository compaction now automatically removes unneeded 17byte
+    commit-only segments, #2850
+- make swidth available on all posix platforms, #2667
+
+Other changes:
+
+- repository: better speed and less stuff moving around by using separate
+  segment files for manifest DELETEs and PUTs, #3947
+- use pyinstaller v3.3.1 to build binaries
+- update bundled zstd code to 1.3.8, #4210
+- update bundled lz4 code to 1.8.3, #4209
+- msgpack:
+
+  - switch to recent "msgpack" pypi pkg name, #3890
+  - wrap msgpack to avoid future compat complications, #3632, #2738
+  - support msgpack 0.6.0 and 0.6.1, #4220, #4308
+
+- llfuse: modernize / simplify llfuse version requirements
+- code refactorings / internal improvements:
+
+  - include size/csize/nfiles[_parts] stats into archive, #3241
+  - calc_stats: use archive stats metadata, if available
+  - crypto: refactored crypto to use an AEAD style API
+  - crypto: new AES-OCB, CHACHA20-POLY1305
+  - create: use less syscalls by not using a python file obj, #906, #3962
+  - diff: refactor the diff functionality to new ItemDiff class, #2475
+  - archive: create FilesystemObjectProcessors class
+  - helpers: make a package, split into smaller modules
+  - xattrs: move to platform package, use cython instead ctypes, #2495
+  - xattrs/acls/bsdflags: misc. code/api optimizations
+  - FUSE: separate creation of filesystem from implementation of llfuse funcs, #3042
+  - FUSE: use unpacker.tell() instead of deprecated write_bytes, #3899
+  - setup.py: move build_man / build_usage code to setup_docs.py
+  - setup.py: update to use a newer Cython/setuptools API for compiling .pyx -> .c, #3788
+  - use python 3.5's os.scandir / os.set_blocking
+  - multithreading preparations (not used yet):
+
+    - item.to_optr(), Item.from_optr()
+    - fix chunker holding the GIL during blocking I/O
+  - C code portability / basic MSC compatibility, #4147, #2677
+- testing:
+
+  - vagrant: new VMs for linux/bsd/darwin, most with OpenSSL 1.1 and py36
+
+
+Version 1.1.18 (2022-06-05)
+---------------------------
+
+Compatibility notes:
+
+- When upgrading from borg 1.0.x to 1.1.x, please note:
+
+  - read all the compatibility notes for 1.1.0*, starting from 1.1.0b1.
+  - borg upgrade: you do not need to and you also should not run it.
+  - borg might ask some security-related questions once after upgrading.
+    You can answer them either manually or via environment variable.
+    One known case is if you use unencrypted repositories, then it will ask
+    about a unknown unencrypted repository one time.
+  - your first backup with 1.1.x might be significantly slower (it might
+    completely read, chunk, hash a lot files) - this is due to the
+    --files-cache mode change (and happens every time you change mode).
+    You can avoid the one-time slowdown by using the pre-1.1.0rc4-compatible
+    mode (but that is less safe for detecting changed files than the default).
+    See the --files-cache docs for details.
+- 1.1.11 removes WSL autodetection (Windows 10 Subsystem for Linux).
+  If WSL still has a problem with sync_file_range, you need to set
+  BORG_WORKAROUNDS=basesyncfile in the borg process environment to
+  work around the WSL issue.
+- 1.1.14 changes return codes due to a bug fix:
+  In case you have scripts expecting rc == 2 for a signal exit, you need to
+  update them to check for >= 128 (as documented since long).
+- 1.1.15 drops python 3.4 support, minimum requirement is 3.5 now.
+- 1.1.17 install_requires the "packaging" pypi package now.
+
+New features:
+
+- check --repair: significantly speed up search for next valid object in segment, #6022
+- create: add retry_erofs workaround for O_NOATIME issue on volume shadow copies in WSL1, #6024
+- key export: display key if path is '-' or not given, #6092
+- list --format: add command_line to format keys, #6108
+
+Fixes:
+
+- check: improve error handling for corrupt archive metadata block,
+  make robust_iterator more robust, #4777
+- diff: support presence change for blkdev, chrdev and fifo items, #6483
+- diff: reduce memory consumption, fix is_hardlink_master
+- init: disallow overwriting of existing keyfiles
+- info: fix authenticated mode repo to show "Encrypted: No", #6462
+- info: emit repo info even if repo has 0 archives, #6120
+- list: remove placeholders for shake_* hashes, #6082
+- mount -o versions: give clear error msg instead of crashing
+- show_progress: add finished=true/false to archive_progress json, #6570
+- fix hardlinkable file type check, #6037
+- do not show archive name in error msgs referring to the repository, #6023
+- prettier error msg (no stacktrace) if exclude file is missing, #5734
+- do not require BORG_CONFIG_DIR if BORG_{SECURITY,KEYS}_DIR are set, #5979
+- atomically create the CACHE_TAG file, #6028
+- deal with the SaveFile/SyncFile race, docs, see #6176 5c5b59bc9
+- avoid expanding path into LHS of formatting operation + tests, #6064 #6063
+- repository: quota / compactable computation fixes, #6119.
+  This is mainly to keep the repo code in sync with borg 1.2. As borg 1.1
+  compacts immediately, there was not really an issue with this in 1.1.
+- fix transaction rollback: use files cache filename as found in txn.active, #6353
+- do not load files cache for commands not using it, fixes #5673
+- fix scp repo url parsing for ip v6 addrs, #6526
+- repo::archive location placeholder expansion fixes, #5826, #5998
+
+  - use expanded location for log output
+  - support placeholder expansion for BORG_REPO env var
+- respect umask for created directory and file modes, #6400
+- safer truncate_and_unlink implementation
+
+Other changes:
+
+- upgrade bundled xxhash code to 0.8.1
+- fix xxh64 related build (setup.py and post-0.8.1 patch for static_assert).
+  The patch was required to build the bundled xxhash code on FreeBSD, see
+  https://github.com/Cyan4973/xxHash/pull/670
+- msgpack build: remove endianness macro, #6105
+- update and fix shell completions
+- fuse: remove unneeded version check and compat code
+- delete --force: do not ask when deleting a repo, #5941
+- delete: don't commit if nothing was deleted, avoid cache sync, #6060
+- delete: add repository id and location to prompt
+- compact segments: improve freeable / freed space log output, #5679
+- if ensure_dir() fails, give more informative error message, #5952
+- load_key: no key is same as empty key, #6441
+- better error msg for defect or unsupported repo configs, #6566
+- use hmac.compare_digest instead of ==, #6470
+- implement more standard hashindex.setdefault behaviour
+- remove stray punctuation from secure-erase message
+- add development.lock.txt, use a real python 3.5 to generate frozen reqs
+- setuptools 60.7.0 breaks pyinstaller, #6246
+- setup.py clean2 was added to work around some setuptools customizability limitation.
+- allow extra compiler flags for every extension build
+- C code: make switch fallthrough explicit
+- Cython code: fix "useless trailing comma" cython warnings
+- requirements.lock.txt: use the latest cython 0.29.30
+- fix compilation warnings: ‘PyUnicode_AsUnicode’ is deprecated
+- docs:
+
+  - ~/.config/borg/keys is not used for repokey keys, #6107
+  - excluded parent dir's metadata can't restore, #6062
+  - permissions note rewritten to make it less confusing, #5490
+  - add note about grandfather-father-son backup retention policy / rotation scheme
+  - clarify who starts the remote agent (borg serve)
+  - test/improve pull backup docs, #5903
+  - document the socat pull mode described in #900 #515ß
+  - borg serve: improve ssh forced commands docs, #6083
+  - improve docs for borg list --format, #6080
+  - fix the broken link to .nix file
+  - clarify pattern usage with commands, #5176
+  - clarify user_id vs uid for fuse, #5723
+  - fix binary build freebsd/macOS version, #5942
+  - FAQ: fix manifest-timestamp path, #6016
+  - remove duplicate faq entries, #5926
+  - fix sphinx warnings, #5919
+  - virtualisation speed tips
+  - fix values of TAG bytes, #6515
+  - recommend umask for passphrase file perms
+  - update link to ubuntu packages, #6485
+  - clarify on-disk order and size of log entry fields, #6357
+  - do not transform --/--- to unicode dashes
+  - improve linking inside docs, link to borg_placeholders, link to borg_patterns
+  - use same phrasing in misc. help texts
+  - borg init: explain the encryption modes better
+  - explain the difference between a path that ends with or without a slash, #6297
+  - clarify usage of patternfile roots, #6242
+  - borg key export: add examples
+  - updates about features not experimental any more: FUSE "versions" view, --pattern*, #6134
+  - fix/update cygwin package requirements
+  - impact of deleting path/to/repo/nonce, #5858
+  - warn about tampered server nonce
+  - mention BORG_FILES_CACHE_SUFFIX as alternative to BORG_FILES_CACHE_TTL, #5602
+  - add a troubleshooting note about "is not a valid repository" to the FAQ
+- vagrant / CI / testing:
+
+  - misc. fixes and updates, new python versions
+  - macOS on github: re-enable fuse2 testing by downgrading to older macOS, #6099
+  - fix OpenBSD symlink mode test failure, #2055
+  - use the generic/openbsd6 box
+  - strengthen the test: we can read data w/o nonces
+  - add tests for path/to/repo/nonce deletion
+  - darwin64: backport some tunings from master
+  - darwin64: remove fakeroot, #6314
+  - darwin64: fix vagrant scp, #5921
+  - darwin64: use macfuse instead of osxfuse
+  - add ubuntu "jammy" 22.04 LTS VM
+  - adapt memory for openindiana64 and darwin64
+
+
+Version 1.1.17 (2021-07-12)
+---------------------------
+
+Compatibility notes:
+
+- When upgrading from borg 1.0.x to 1.1.x, please note:
+
+  - read all the compatibility notes for 1.1.0*, starting from 1.1.0b1.
+  - borg upgrade: you do not need to and you also should not run it.
+  - borg might ask some security-related questions once after upgrading.
+    You can answer them either manually or via environment variable.
+    One known case is if you use unencrypted repositories, then it will ask
+    about a unknown unencrypted repository one time.
+  - your first backup with 1.1.x might be significantly slower (it might
+    completely read, chunk, hash a lot files) - this is due to the
+    --files-cache mode change (and happens every time you change mode).
+    You can avoid the one-time slowdown by using the pre-1.1.0rc4-compatible
+    mode (but that is less safe for detecting changed files than the default).
+    See the --files-cache docs for details.
+- 1.1.11 removes WSL autodetection (Windows 10 Subsystem for Linux).
+  If WSL still has a problem with sync_file_range, you need to set
+  BORG_WORKAROUNDS=basesyncfile in the borg process environment to
+  work around the WSL issue.
+- 1.1.14 changes return codes due to a bug fix:
+  In case you have scripts expecting rc == 2 for a signal exit, you need to
+  update them to check for >= 128 (as documented since long).
+- 1.1.15 drops python 3.4 support, minimum requirement is 3.5 now.
+- 1.1.17 install_requires the "packaging" pypi package now.
+
+Fixes:
+
+- pyinstaller dir-mode: fix pyi detection / LIBPATH treatment, #5897
+- handle crash due to kill stale lock race, #5828
+- fix BORG_CACHE_DIR crashing borg if empty, #5216
+- create --dry-run: fix display of kept tagfile, #5834
+- fix missing parameter in "did not consistently fail" msg, #5822
+- missing / healed chunks: always tell chunk ID, #5704
+- benchmark: make sure cleanup happens even on exceptions, #5630
+
+New features:
+
+- implement BORG_SELFTEST env variable, #5871.
+  this can be used to accelerate borg startup a bit. not recommended for
+  normal usage, but borg mass hosters with a lot of borg invocations can
+  save some resources with this. on my laptop, this saved ~100ms cpu time
+  (sys+user) per borg command invocation.
+- implement BORG_LIBC env variable to give the libc filename, #5870.
+  you can use this if a borg does not find your libc.
+- check: add progress indicator for archive check.
+- allow --files-cache=size (not recommended, make sure you know what you do)
+
+Other changes:
+
+- Python 3.10 now officially supported!
+  we test on py310-dev on github CI since a while and now also on the vagrant
+  machines, so it should work ok.
+- github CI: test on py310 (again)
+- get rid of distutils, use packaging and setuptools.
+  distutils is deprecated and gives warnings on py 3.10.
+- setup.py: rename "clean" to "clean2" to avoid shadowing the "clean" command.
+- remove libc filename fallback for the BSDs (there is no "usual" name)
+- cleanup flake8 checks, fix some pep8 violations.
+- docs building: replace deprecated function ".add_stylesheet()" for Sphinx 4 compatibility
+- docs:
+
+  - add a hint on sleeping computer and ssh connections, #5301
+  - update the documentation on hacked backup client, #5480
+  - improve docs/FAQ about append-only remote repos, #5497
+  - complement the documentation for pattern files and exclude files, #5520
+  - "filename with spaces" example added to exclude file, #5236
+    note: no whitespace escaping needed, processed by borg.
+  - add info on renaming repositories, #5240
+  - clarify borg check --verify-data, #5808
+  - add notice about defective hardware to check documentation, #5753
+  - add paragraph added in #5855 to utility documentation source
+  - add missing leading slashes in help patterns, #5857
+  - clarify "you will need key and passphrase" borg init warning, #4622
+  - pull mode: add some warnings, #5827
+  - mention tar --compare (compare archive to fs files), #5880
+  - fix typos, backport of #5597
+- vagrant:
+
+  - add py3.7.11 for binary build, also add 3.10-dev.
+  - use latest Cython 0.29.23 for py310 compat fixes.
+  - more RAM for openindiana upgrade plan resolver, it just hangs (swaps?) if
+    there is too little RAM.
+  - fix install_pyenv to adapt to recent changes in pyenv (same as in master now).
+  - use generic/netbsd9 box, copied from master branch.
+
+
+Version 1.1.16 (2021-03-23)
+---------------------------
+
+Fixes:
+
+- setup.py: add special openssl prefix for Apple M1 compatibility
+- do not recurse into duplicate roots, #5603
+- remove empty shadowed_segments lists, #5275, #5614
+- fix libpython load error when borg fat binary / dir-based binary is invoked
+  via a symlink by upgrading pyinstaller to v4.2, #5688
+- config: accept non-int value (like 500M or 100G) for max_segment_size or
+  storage_quota, #5639.
+  please note: when setting a non-int value for this in a repo config,
+  using the repo will require borg >= 1.1.16.
+
+New features:
+
+- bundled msgpack: drop support for old buffer protocol to support Python 3.10
+- verbose files cache logging via --debug-topic=files_cache, #5659.
+  Use this if you suspect that borg does not detect unmodified files as expected.
+- create/extract: add --noxattrs and --noacls option, #3955.
+  when given with borg create, borg will not get xattrs / ACLs from input files
+  (and thus, it will not archive xattrs / ACLs). when given with borg extract,
+  borg will not read xattrs / ACLs from archive and will not set xattrs / ACLs
+  on extracted files.
+- diff: add --json-lines option, #3765
+- check: debug log segment filename
+- borg debug dump-hints
+
+Other changes:
+
+- Tab completion support for additional archives for 'borg delete'
+- repository: deduplicate code of put and delete, no functional change
+- tests: fix result order issue (sporadic test failure on openindiana)
+- vagrant:
+
+  - upgrade pyinstaller to v4.2, #5671
+  - avoid grub-install asking interactively for device
+  - remove the xenial box
+  - update freebsd box to 12.1
+- docs:
+
+  - update macOS install instructions, #5677
+  - use macFUSE (not osxfuse) for Apple M1 compatibility
+  - update docs for dev environment installation instructions, #5643
+  - fix grammar in faq
+  - recommend running tests only on installed versions for setup
+  - add link back to git-installation
+  - remove /var/cache exclusion in example commands, #5625.
+    This is generally a poor idea and shouldn't be promoted through examples.
+  - add repology.org badge with current packaging status
+  - explain hash collision
+  - add unsafe workaround to use an old repo copy, #5722
+
+
+Version 1.1.15 (2020-12-25)
+---------------------------
+
+Fixes:
+
+- extract:
+
+  - improve exception handling when setting xattrs, #5092.
+  - emit a warning message giving the path, xattr key and error message.
+  - continue trying to restore other xattrs and bsdflags of the same file
+    after an exception with xattr-setting happened.
+- export-tar:
+
+  - set tar format to GNU_FORMAT explicitly, #5274
+  - fix memory leak with ssh: remote repository, #5568
+  - fix potential memory leak with ssh: remote repository with partial extraction
+- create: fix --dry-run and --stats coexistence, #5415
+- use --timestamp for {utcnow} and {now} if given, #5189
+
+New features:
+
+- create: implement --stdin-mode, --stdin-user and --stdin-group, #5333
+- allow appending the files cache filename with BORG_FILES_CACHE_SUFFIX env var
+
+Other changes:
+
+- drop python 3.4 support, minimum requirement is 3.5 now.
+- enable using libxxhash instead of bundled xxh64 code
+- update llfuse requirements (1.3.8)
+- set cython language_level in some files to fix warnings
+- allow EIO with warning when trying to hardlink
+- PropDict: fail early if internal_dict is not a dict
+- update shell completions
+- tests / CI
+
+  - add a test for the hashindex corruption bug, #5531 #4829
+  - fix spurious failure in test_cache_files, #5438
+  - added a github ci workflow
+  - reduce testing on travis, no macOS, no py3x-dev, #5467
+  - travis: use newer dists, native py on dist
+- vagrant:
+
+  - remove jessie and trusty boxes, #5348 #5383
+  - pyinstaller 4.0, build on py379
+  - binary build on stretch64, #5348
+  - remove easy_install based pip installation
+- docs:
+
+  - clarify '--one-file-system' for btrfs, #5391
+  - add example for excluding content using the --pattern cmd line arg
+  - complement the documentation for pattern files and exclude files, #5524
+  - made ansible playbook more generic, use package instead of pacman. also
+    change state from "latest" to "present".
+  - complete documentation on append-only remote repos, #5497
+  - internals: rather talk about target size than statistics, #5336
+  - new compression algorithm policy, #1633 #5505
+  - faq: add a hint on sleeping computer, #5301
+  - note requirements for full disk access on macOS Catalina, #5303
+  - fix/improve description of borg upgrade hardlink usage, #5518
+- modernize 1.1 code:
+
+  - drop code/workarounds only needed to support Python 3.4
+  - remove workaround for pre-release py37 argparse bug
+  - removed some outdated comments/docstrings
+  - requirements: remove some restrictions, lock on current versions
+
+
+Version 1.1.14 (2020-10-07)
+---------------------------
+
+Fixes:
+
+- check --repair: fix potential data loss when interrupting it, #5325
+- exit with 128 + signal number (as documented) when borg is killed by a signal, #5161
+- fix hardlinked CACHEDIR.TAG processing, #4911
+- create --read-special: .part files also should be regular files, #5217
+- llfuse dependency: choose least broken 1.3.6/1.3.7.
+  1.3.6 is broken on python 3.9, 1.3.7 is broken on FreeBSD.
+
+Other changes:
+
+- upgrade bundled xxhash to 0.7.4
+- self test: if it fails, also point to OS and hardware, #5334
+- pyinstaller: compute basepath from spec file location
+- prettier error message when archive gets too big, #5307
+- check/recreate are not "experimental" any more (but still potentially dangerous):
+
+  - recreate: remove extra confirmation
+  - rephrase some warnings, update docs, #5164
+- shell completions:
+
+  - misc. updates / fixes
+  - support repositories in fish tab completion, #5256
+  - complete $BORG_RECREATE_I_KNOW_WHAT_I_AM_DOING
+  - rewrite zsh completion:
+
+    - completion for almost all optional and positional arguments
+    - completion for Borg environment variables (parameters)
+- use "allow/deny list" instead of "white/black list" wording
+- declare "allow_cache_wipe" marker in setup.cfg to avoid pytest warning
+- vagrant / tests:
+
+  - misc. fixes / updates
+  - use python 3.5.10 for binary build
+  - build directory-based binaries additionally to the single file binaries
+  - add libffi-dev, required to build python
+  - use cryptography<3.0, more recent versions break the jessie box
+  - test on python 3.9
+  - do brew update with /dev/null redirect to avoid "too much log output" on travis-ci
+- docs:
+
+  - add ssh-agent pull backup method docs, #5288
+  - how to approach borg speed issues, #5371
+  - mention double --force in prune docs
+  - update Homebrew install instructions, #5185
+  - better description of how cache and rebuilds of it work
+  - point to borg create --list item flags in recreate usage, #5165
+  - add security faq explaining AES-CTR crypto issues, #5254
+  - add a note to create from stdin regarding files cache, #5180
+  - fix borg.1 manpage generation regression, #5211
+  - clarify how exclude options work in recreate, #5193
+  - add section for retired contributors
+  - hint about not misusing private email addresses of contributors for borg support
+
+
+Version 1.1.13 (2020-06-06)
+---------------------------
+
+Compatibility notes:
+
+- When upgrading from borg 1.0.x to 1.1.x, please note:
+
+  - read all the compatibility notes for 1.1.0*, starting from 1.1.0b1.
+  - borg upgrade: you do not need to and you also should not run it.
+  - borg might ask some security-related questions once after upgrading.
+    You can answer them either manually or via environment variable.
+    One known case is if you use unencrypted repositories, then it will ask
+    about a unknown unencrypted repository one time.
+  - your first backup with 1.1.x might be significantly slower (it might
+    completely read, chunk, hash a lot files) - this is due to the
+    --files-cache mode change (and happens every time you change mode).
+    You can avoid the one-time slowdown by using the pre-1.1.0rc4-compatible
+    mode (but that is less safe for detecting changed files than the default).
+    See the --files-cache docs for details.
+- 1.1.11 removes WSL autodetection (Windows 10 Subsystem for Linux).
+  If WSL still has a problem with sync_file_range, you need to set
+  BORG_WORKAROUNDS=basesyncfile in the borg process environment to
+  work around the WSL issue.
+
+Fixes:
+
+- rebuilt using a current Cython version, compatible with python 3.8, #5214
+
+
+Version 1.1.12 (2020-06-06)
+---------------------------
+
+Fixes:
+
+- fix preload-related memory leak, #5202.
+- mount / borgfs (FUSE filesystem):
+
+  - fix FUSE low linear read speed on large files, #5067
+  - fix crash on old llfuse without birthtime attrs, #5064 - accidentally
+    we required llfuse >= 1.3. Now also old llfuse works again.
+  - set f_namemax in statfs result, #2684
+- update precedence of env vars to set config and cache paths, #4894
+- correctly calculate compression ratio, taking header size into account, too
+
+New features:
+
+- --bypass-lock option to bypass locking with read-only repositories
+
+Other changes:
+
+- upgrade bundled zstd to 1.4.5
+- travis: adding comments and explanations to Travis config / install script,
+  improve macOS builds.
+- tests: test_delete_force: avoid sporadic test setup issues, #5196
+- misc. vagrant fixes
+- the binary for macOS is now built on macOS 10.12
+- the binaries for Linux are now built on Debian 8 "Jessie", #3761
+- docs:
+
+  - PlaceholderError not printed as JSON, #4073
+  - "How important is Borg config?", #4941
+  - make Sphinx warnings break docs build, #4587
+  - some markup / warning fixes
+  - add "updating borgbackup.org/releases" to release checklist, #4999
+  - add "rendering docs" to release checklist, #5000
+  - clarify borg init's encryption modes
+  - add note about patterns and stored paths, #4160
+  - add upgrade of tools to pip installation how-to
+  - document one cause of orphaned chunks in check command, #2295
+  - linked recommended restrictions to ssh public keys on borg servers in faq, #4946
+
+
+Version 1.1.11 (2020-03-08)
+---------------------------
+
+Compatibility notes:
+
+- When upgrading from borg 1.0.x to 1.1.x, please note:
+
+  - read all the compatibility notes for 1.1.0*, starting from 1.1.0b1.
+  - borg upgrade: you do not need to and you also should not run it.
+  - borg might ask some security-related questions once after upgrading.
+    You can answer them either manually or via environment variable.
+    One known case is if you use unencrypted repositories, then it will ask
+    about a unknown unencrypted repository one time.
+  - your first backup with 1.1.x might be significantly slower (it might
+    completely read, chunk, hash a lot files) - this is due to the
+    --files-cache mode change (and happens every time you change mode).
+    You can avoid the one-time slowdown by using the pre-1.1.0rc4-compatible
+    mode (but that is less safe for detecting changed files than the default).
+    See the --files-cache docs for details.
+- 1.1.11 removes WSL autodetection (Windows 10 Subsystem for Linux).
+  If WSL still has a problem with sync_file_range, you need to set
+  BORG_WORKAROUNDS=basesyncfile in the borg process environment to
+  work around the WSL issue.
+
+Fixes:
+
+- fixed potential index corruption / data loss issue due to bug in hashindex_set, #4829.
+  Please read and follow the more detailed notes close to the top of this document.
+- upgrade bundled xxhash to 0.7.3, #4891.
+  0.7.2 is the minimum requirement for correct operations on ARMv6 in non-fixup
+  mode, where unaligned memory accesses cause bus errors.
+  0.7.3 adds some speedups and libxxhash 0.7.3 even has a pkg-config file now.
+- upgrade bundled lz4 to 1.9.2
+- upgrade bundled zstd to 1.4.4
+- fix crash when upgrading erroneous hints file, #4922
+- extract:
+
+  - fix KeyError for "partial" extraction, #4607
+  - fix "partial" extract for hardlinked contentless file types, #4725
+  - fix preloading for old (0.xx) remote servers, #4652
+  - fix confusing output of borg extract --list --strip-components, #4934
+- delete: after double-force delete, warn about necessary repair, #4704
+- create: give invalid repo error msg if repo config not found, #4411
+- mount: fix FUSE mount missing st_birthtime, #4763 #4767
+- check: do not stumble over invalid item key, #4845
+- info: if the archive doesn't exist, print a pretty message, #4793
+- SecurityManager.known(): check all files, #4614
+- Repository.open: use stat() to check for repo dir, #4695
+- Repository.check_can_create_repository: use stat() to check, #4695
+- fix invalid archive error message
+- fix optional/non-optional location arg, #4541
+- commit-time free space calc: ignore bad compact map entries, #4796
+- ignore EACCES (errno 13) when hardlinking the old config, #4730
+- --prefix / -P: fix processing, avoid argparse issue, #4769
+
+New features:
+
+- enable placeholder usage in all extra archive arguments
+- new BORG_WORKAROUNDS mechanism, basesyncfile, #4710
+- recreate: support --timestamp option, #4745
+- support platforms without os.link (e.g. Android with Termux), #4901.
+  if we don't have os.link, we just extract another copy instead of making a hardlink.
+- support linux platforms without sync_file_range (e.g. Android 7 with Termux), #4905
+
+Other:
+
+- ignore --stats when given with --dry-run, but continue, #4373
+- add some ProgressIndicator msgids to code / fix docs, #4935
+- elaborate on "Calculating size" message
+- argparser: always use REPOSITORY in metavar, also use more consistent help phrasing.
+- check: improve error output for matching index size, see #4829
+- docs:
+
+  - changelog: add advisory about hashindex_set bug #4829
+  - better describe BORG_SECURITY_DIR, BORG_CACHE_DIR, #4919
+  - infos about cache security assumptions, #4900
+  - add FAQ describing difference between a local repo vs. repo on a server.
+  - document how to test exclusion patterns without performing an actual backup
+  - timestamps in the files cache are now usually ctime, #4583
+  - fix bad reference to borg compact (does not exist in 1.1), #4660
+  - create: borg 1.1 is not future any more
+  - extract: document limitation "needs empty destination", #4598
+  - how to supply a passphrase, use crypto devices, #4549
+  - fix osxfuse github link in installation docs
+  - add example of exclude-norecurse rule in help patterns
+  - update macOS Brew link
+  - add note about software for automating backups, #4581
+  - AUTHORS: mention copyright+license for bundled msgpack
+  - fix various code blocks in the docs, #4708
+  - updated docs to cover use of temp directory on remote, #4545
+  - add restore docs, #4670
+  - add a pull backup / push restore how-to, #1552
+  - add FAQ how to retain original paths, #4532
+  - explain difference between --exclude and --pattern, #4118
+  - add FAQs for SSH connection issues, #3866
+  - improve password FAQ, #4591
+  - reiterate that 'file cache names are absolute' in FAQ
+- tests:
+
+  - cope with ANY error when importing pytest into borg.testsuite, #4652
+  - fix broken test that relied on improper zlib assumptions
+  - test_fuse: filter out selinux xattrs, #4574
+- travis / vagrant:
+
+  - misc python versions removed / changed (due to openssl 1.1 compatibility)
+    or added (3.7 and 3.8, for better borg compatibility testing)
+  - binary building is on python 3.5.9 now
+- vagrant:
+
+  - add new boxes: ubuntu 18.04 and 20.04, debian 10
+  - update boxes: openindiana, darwin, netbsd
+  - remove old boxes: centos 6
+  - darwin: updated osxfuse to 3.10.4
+  - use debian/ubuntu pip/virtualenv packages
+  - rather use python 3.6.2 than 3.6.0, fixes coverage/sqlite3 issue
+  - use requirements.d/development.lock.txt to avoid compat issues
+- travis:
+
+  - darwin: backport some install code / order from master
+  - remove deprecated keyword "sudo" from travis config
+  - allow osx builds to fail, #4955
+    this is due to travis-ci frequently being so slow that the OS X builds
+    just fail because they exceed 50 minutes and get killed by travis.
+
+
+Version 1.1.10 (2019-05-16)
+---------------------------
+
+Fixes:
+
+- extract: hang on partial extraction with ssh: repo, when hardlink master
+  is not matched/extracted and borg hangs on related slave hardlink, #4350
+- lrucache: regularly remove old FDs, #4427
+- avoid stale filehandle issues, #3265
+- freebsd: make xattr platform code api compatible with linux, #3952
+- use whitelist approach for borg serve, #4097
+- borg command shall terminate with rc 2 for ImportErrors, #4424
+- create: only run stat_simple_attrs() once, this increases
+  backup with lots of unchanged files performance by ~ 5%.
+- prune: fix incorrect borg prune --stats output with --dry-run, #4373
+- key export: emit user-friendly error if repo key is exported to a directory,
+  #4348
+
+New features:
+
+- bundle latest supported msgpack-python release (0.5.6), remove msgpack-python
+  from setup.py install_requires - by default we use the bundled code now.
+  optionally, we still support using an external msgpack (see hints in
+  setup.py), but this requires solid requirements management within
+  distributions and is not recommended.
+  borgbackup will break if you upgrade msgpack to an unsupported version.
+- display msgpack version as part of sysinfo (e.g. in tracebacks)
+- timestamp for borg delete --info added, #4359
+- enable placeholder usage in --comment and --glob-archives, #4559, #4495
+
+Other:
+
+- serve: do not check python/libc for borg serve, #4483
+- shell completions: borg diff second archive
+- release scripts: signing binaries with Qubes OS support
+- testing:
+
+  - vagrant: upgrade openbsd box to 6.4
+  - travis-ci: lock test env to py 3.4 compatible versions, #4343
+  - get rid of confusing coverage warning, #2069
+  - rename test_mount_hardlinks to test_fuse_mount_hardlinks,
+    so both can be excluded by "not test_fuse".
+  - pure-py msgpack warning shall not make a lot of tests fail, #4558
+- docs:
+
+  - add "SSH Configuration" section to "borg serve", #3988, #636, #4485
+  - README: new URL for funding options
+  - add a sample logging.conf in docs/misc, #4380
+  - elaborate on append-only mode docs, #3504
+  - installation: added Alpine Linux to distribution list, #4415
+  - usage.html: only modify window.location when redirecting, #4133
+  - add msgpack license to docs/3rd_party/msgpack
+- vagrant / binary builds:
+
+  - use python 3.5.7 for builds
+  - use osxfuse 3.8.3
+
+
+Version 1.1.9 (2019-02-10)
+--------------------------
+
+Compatibility notes:
+
+- When upgrading from borg 1.0.x to 1.1.x, please note:
+
+  - read all the compatibility notes for 1.1.0*, starting from 1.1.0b1.
+  - borg upgrade: you do not need to and you also should not run it.
+  - borg might ask some security-related questions once after upgrading.
+    You can answer them either manually or via environment variable.
+    One known case is if you use unencrypted repositories, then it will ask
+    about a unknown unencrypted repository one time.
+  - your first backup with 1.1.x might be significantly slower (it might
+    completely read, chunk, hash a lot files) - this is due to the
+    --files-cache mode change (and happens every time you change mode).
+    You can avoid the one-time slowdown by using the pre-1.1.0rc4-compatible
+    mode (but that is less safe for detecting changed files than the default).
+    See the --files-cache docs for details.
+
+Fixes:
+
+- security fix: configure FUSE with "default_permissions", #3903
+  "default_permissions" is now enforced by borg by default to let the
+  kernel check uid/gid/mode based permissions.
+  "ignore_permissions" can be given to not enforce "default_permissions".
+- make "hostname" short, even on misconfigured systems, #4262
+- fix free space calculation on macOS (and others?), #4289
+- config: quit with error message when no key is provided, #4223
+- recover_segment: handle too small segment files correctly, #4272
+- correctly release memoryview, #4243
+- avoid diaper pattern in configparser by opening files, #4263
+- add "# cython: language_level=3" directive to .pyx files, #4214
+- info: consider part files for "This archive" stats, #3522
+- work around Microsoft WSL issue #645 (sync_file_range), #1961
+
+New features:
+
+- add --rsh command line option to complement BORG_RSH env var, #1701
+- init: --make-parent-dirs parent1/parent2/repo_dir, #4235
+
+Other:
+
+- add archive name to check --repair output, #3447
+- check for unsupported msgpack versions
+- shell completions:
+
+  - new shell completions for borg 1.1.9
+  - more complete shell completions for borg mount -o
+  - added shell completions for borg help
+  - option arguments for zsh tab completion
+- docs:
+
+  - add FAQ regarding free disk space check, #3905
+  - update BORG_PASSCOMMAND example and clarify variable expansion, #4249
+  - FAQ regarding change of compression settings, #4222
+  - add note about BSD flags to changelog, #4246
+  - improve logging in example automation script
+  - add note about files changing during backup, #4081
+  - work around the backslash issue, #4280
+  - update release workflow using twine (docs, scripts), #4213
+  - add warnings on repository copies to avoid future problems, #4272
+- tests:
+
+  - fix the homebrew 1.9 issues on travis-ci, #4254
+  - fix duplicate test method name, #4311
+
+
+Version 1.1.8 (2018-12-09)
+--------------------------
+
+Fixes:
+
+- enforce storage quota if set by serve-command, #4093
+- invalid locations: give err msg containing parsed location, #4179
+- list repo: add placeholders for hostname and username, #4130
+- on linux, symlinks can't have ACLs, so don't try to set any, #4044
+
+New features:
+
+- create: added PATH::archive output on INFO log level
+- read a passphrase from a file descriptor specified in the
+  BORG_PASSPHRASE_FD environment variable.
+
+Other:
+
+- docs:
+
+  - option --format is required for some expensive-to-compute values for json
+
+    borg list by default does not compute expensive values except when
+    they are needed. whether they are needed is determined by the format,
+    in standard mode as well as in --json mode.
+  - tell that our binaries are x86/x64 amd/intel, bauerj has ARM
+  - fixed wrong archive name pattern in CRUD benchmark help
+  - fixed link to cachedir spec in docs, #4140
+- tests:
+
+  - stop using fakeroot on travis, avoids sporadic EISDIR errors, #2482
+  - xattr key names must start with "user." on linux
+  - fix code so flake8 3.6 does not complain
+  - explicitly convert environment variable to str, #4136
+  - fix DeprecationWarning: Flags not at the start of the expression, #4137
+  - support pytest4, #4172
+- vagrant:
+
+  - use python 3.5.6 for builds
+
+
+Version 1.1.7 (2018-08-11)
+--------------------------
+
+Compatibility notes:
+
+- added support for Python 3.7
+
+Fixes:
+
+- cache lock: use lock_wait everywhere to fix infinite wait, see #3968
+- don't archive tagged dir when recursing an excluded dir, #3991
+- py37 argparse: work around bad default in py 3.7.0a/b/rc, #3996
+- py37 remove loggerDict.clear() from tearDown method, #3805
+- some fixes for bugs which likely did not result in problems in practice:
+
+  - fixed logic bug in platform module API version check
+  - fixed xattr/acl function prototypes, added missing ones
+
+New features:
+
+- init: add warning to store both key and passphrase at safe place(s)
+- BORG_HOST_ID env var to work around all-zero MAC address issue, #3985
+- borg debug dump-repo-objs --ghost (dump everything from segment files,
+  including deleted or superseded objects or commit tags)
+- borg debug search-repo-objs (search in repo objects for hex bytes or strings)
+
+Other changes:
+
+- add Python 3.7 support
+- updated shell completions
+- call socket.gethostname only once
+- locking: better logging, add some asserts
+- borg debug dump-repo-objs:
+
+  - filename layout improvements
+  - use repository.scan() to get on-disk order
+- docs:
+
+  - update installation instructions for macOS
+  - added instructions to install fuse via homebrew
+  - improve diff docs
+  - added note that checkpoints inside files requires 1.1+
+  - add link to tempfile module
+  - remove row/column-spanning from docs source, #4000 #3990
+- tests:
+
+  - fetch less data via os.urandom
+  - add py37 env for tox
+  - travis: add 3.7, remove 3.6-dev (we test with -dev in master)
+- vagrant / binary builds:
+
+  - use osxfuse 3.8.2
+  - use own (uptodate) openindiana box
+
+
+Version 1.1.6 (2018-06-11)
+--------------------------
+
+Compatibility notes:
+
+- 1.1.6 changes:
+
+  - also allow msgpack-python 0.5.6.
+
+Fixes:
+
+- fix borg exception handling on ENOSPC error with xattrs, #3808
+- prune: fix/improve overall progress display
+- borg config repo ... does not need cache/manifest/key, #3802
+- debug dump-repo-objs should not depend on a manifest obj
+- pypi package:
+
+  - include .coveragerc, needed by tox.ini
+  - fix package long description, #3854
+
+New features:
+
+- mount: add uid, gid, umask mount options
+- delete:
+
+  - only commit once, #3823
+  - implement --dry-run, #3822
+- check:
+
+  - show progress while rebuilding missing manifest, #3787
+  - more --repair output
+- borg config --list <repo>, #3612
+
+Other changes:
+
+- update msgpack requirement, #3753
+- update bundled zstd to 1.3.4, #3745
+- update bundled lz4 code to 1.8.2, #3870
+- docs:
+
+  - describe what BORG_LIBZSTD_PREFIX does
+  - fix and deduplicate encryption quickstart docs, #3776
+- vagrant:
+
+  - FUSE for macOS: upgrade 3.7.1 to 3.8.0
+  - exclude macOS High Sierra upgrade on the darwin64 machine
+  - remove borgbackup.egg-info dir in fs_init (after rsync)
+  - use pyenv-based build/test on jessie32/62
+  - use local 32 and 64bit debian jessie boxes
+  - use "vagrant" as username for new xenial box
+- travis OS X: use xcode 8.3 (not broken)
+
+
+Version 1.1.5 (2018-04-01)
+--------------------------
+
+Compatibility notes:
+
+- 1.1.5 changes:
+
+  - require msgpack-python >= 0.4.6 and < 0.5.0.
+    0.5.0+ dropped python 3.4 testing and also caused some other issues because
+    the python package was renamed to msgpack and emitted some FutureWarning.
+
+Fixes:
+
+- create --list: fix that it was never showing M status, #3492
+- create: fix timing for first checkpoint (read files cache early, init
+  checkpoint timer after that), see #3394
+- extract: set rc=1 when extracting damaged files with all-zero replacement
+  chunks or with size inconsistencies, #3448
+- diff: consider an empty file as different to a non-existing file, #3688
+- files cache: improve exception handling, #3553
+- ignore exceptions in scandir_inorder() caused by an implicit stat(),
+  also remove unneeded sort, #3545
+- fixed tab completion problem where a space is always added after path even
+  when it shouldn't
+- build: do .h file content checks in binary mode, fixes build issue for
+  non-ascii header files on pure-ascii locale platforms, #3544 #3639
+- borgfs: fix patterns/paths processing, #3551
+- config: add some validation, #3566
+- repository config: add validation for max_segment_size, #3592
+- set cache previous_location on load instead of save
+- remove platform.uname() call which caused library mismatch issues, #3732
+- add exception handler around deprecated platform.linux_distribution() call
+- use same datetime object for {now} and {utcnow}, #3548
+
+New features:
+
+- create: implement --stdin-name, #3533
+- add chunker_params to borg archive info (--json)
+- BORG_SHOW_SYSINFO=no to hide system information from exceptions
+
+Other changes:
+
+- updated zsh completions for borg 1.1.4
+- files cache related code cleanups
+- be more helpful when parsing invalid --pattern values, #3575
+- be more clear in secure-erase warning message, #3591
+- improve getpass user experience, #3689
+- docs build: unicode problem fixed when using a py27-based sphinx
+- docs:
+
+  - security: explicitly note what happens OUTSIDE the attack model
+  - security: add note about combining compression and encryption
+  - security: describe chunk size / proximity issue, #3687
+  - quickstart: add note about permissions, borg@localhost, #3452
+  - quickstart: add introduction to repositories & archives, #3620
+  - recreate --recompress: add missing metavar, clarify description, #3617
+  - improve logging docs, #3549
+  - add an example for --pattern usage, #3661
+  - clarify path semantics when matching, #3598
+  - link to offline documentation from README, #3502
+  - add docs on how to verify a signed release with GPG, #3634
+  - chunk seed is generated per repository (not: archive)
+  - better formatting of CPU usage documentation, #3554
+  - extend append-only repo rollback docs, #3579
+- tests:
+
+  - fix erroneously skipped zstd compressor tests, #3606
+  - skip a test if argparse is broken, #3705
+- vagrant:
+
+  - xenial64 box now uses username 'vagrant', #3707
+  - move cleanup steps to fs_init, #3706
+  - the boxcutter wheezy boxes are 404, use local ones
+  - update to Python 3.5.5 (for binary builds)
+
+
+Version 1.1.4 (2017-12-31)
+--------------------------
+
+Compatibility notes:
+
+- When upgrading from borg 1.0.x to 1.1.x, please note:
+
+  - read all the compatibility notes for 1.1.0*, starting from 1.1.0b1.
+  - borg upgrade: you do not need to and you also should not run it.
+  - borg might ask some security-related questions once after upgrading.
+    You can answer them either manually or via environment variable.
+    One known case is if you use unencrypted repositories, then it will ask
+    about a unknown unencrypted repository one time.
+  - your first backup with 1.1.x might be significantly slower (it might
+    completely read, chunk, hash a lot files) - this is due to the
+    --files-cache mode change (and happens every time you change mode).
+    You can avoid the one-time slowdown by using the pre-1.1.0rc4-compatible
+    mode (but that is less safe for detecting changed files than the default).
+    See the --files-cache docs for details.
+- borg 1.1.4 changes:
+
+  - zstd compression is new in borg 1.1.4, older borg can't handle it.
+  - new minimum requirements for the compression libraries - if the required
+    versions (header and lib) can't be found at build time, bundled code will
+    be used:
+
+    - added requirement: libzstd >= 1.3.0 (bundled: 1.3.2)
+    - updated requirement: liblz4 >= 1.7.0 / r129 (bundled: 1.8.0)
+
+Fixes:
+
+- check: data corruption fix: fix for borg check --repair malfunction, #3444.
+  See the more detailed notes close to the top of this document.
+- delete: also delete security dir when deleting a repo, #3427
+- prune: fix building the "borg prune" man page, #3398
+- init: use given --storage-quota for local repo, #3470
+- init: properly quote repo path in output
+- fix startup delay with dns-only own fqdn resolving, #3471
+
+New features:
+
+- added zstd compression. try it!
+- added placeholder {reverse-fqdn} for fqdn in reverse notation
+- added BORG_BASE_DIR environment variable, #3338
+
+Other changes:
+
+- list help topics when invalid topic is requested
+- fix lz4 deprecation warning, requires lz4 >= 1.7.0 (r129)
+- add parens for C preprocessor macro argument usages (did not cause malfunction)
+- exclude broken pytest 3.3.0 release
+- updated fish/bash completions
+- init: more clear exception messages for borg create, #3465
+- docs:
+
+  - add auto-generated docs for borg config
+  - don't generate HTML docs page for borgfs, #3404
+  - docs update for lz4 b2 zstd changes
+  - add zstd to compression help, readme, docs
+  - update requirements and install docs about bundled lz4 and zstd
+- refactored build of the compress and crypto.low_level extensions, #3415:
+
+  - move some lib/build related code to setup_{zstd,lz4,b2}.py
+  - bundle lz4 1.8.0 (requirement: >= 1.7.0 / r129)
+  - bundle zstd 1.3.2 (requirement: >= 1.3.0)
+  - blake2 was already bundled
+  - rename BORG_LZ4_PREFIX env var to BORG_LIBLZ4_PREFIX for better consistency:
+    we also have BORG_LIBB2_PREFIX and BORG_LIBZSTD_PREFIX now.
+  - add prefer_system_lib* = True settings to setup.py - by default the build
+    will prefer a shared library over the bundled code, if library and headers
+    can be found and meet the minimum requirements.
+
+
+Version 1.1.3 (2017-11-27)
+--------------------------
+
+Fixes:
+
+- Security Fix for CVE-2017-15914: Incorrect implementation of access controls
+  allows remote users to override repository restrictions in Borg servers.
+  A user able to access a remote Borg SSH server is able to circumvent access
+  controls post-authentication.
+  Affected releases: 1.1.0, 1.1.1, 1.1.2. Releases 1.0.x are NOT affected.
+- crc32: deal with unaligned buffer, add tests - this broke borg on older ARM
+  CPUs that can not deal with unaligned 32bit memory accesses and raise a bus
+  error in such cases. the fix might also improve performance on some CPUs as
+  all 32bit memory accesses by the crc32 code are properly aligned now. #3317
+- mount: fixed support of --consider-part-files and do not show .borg_part_N
+  files by default in the mounted FUSE filesystem. #3347
+- fixed cache/repo timestamp inconsistency message, highlight that information
+  is obtained from security dir (deleting the cache will not bypass this error
+  in case the user knows this is a legitimate repo).
+- borgfs: don't show sub-command in borgfs help, #3287
+- create: show an error when --dry-run and --stats are used together, #3298
+
+New features:
+
+- mount: added exclusion group options and paths, #2138
+
+  Reused some code to support similar options/paths as borg extract offers -
+  making good use of these to only mount a smaller subset of dirs/files can
+  speed up mounting a lot and also will consume way less memory.
+
+  borg mount [options] repo_or_archive mountpoint path [paths...]
+
+  paths: you can just give some "root paths" (like for borg extract) to
+  only partially populate the FUSE filesystem.
+
+  new options: --exclude[-from], --pattern[s-from], --strip-components
+- create/extract: support st_birthtime on platforms supporting it, #3272
+- add "borg config" command for querying/setting/deleting config values, #3304
+
+Other changes:
+
+- clean up and simplify packaging (only package committed files, do not install
+  .c/.h/.pyx files)
+- docs:
+
+  - point out tuning options for borg create, #3239
+  - add instructions for using ntfsclone, zerofree, #81
+  - move image backup-related FAQ entries to a new page
+  - clarify key aliases for borg list --format, #3111
+  - mention break-lock in checkpointing FAQ entry, #3328
+  - document sshfs rename workaround, #3315
+  - add FAQ about removing files from existing archives
+  - add FAQ about different prune policies
+  - usage and man page for borgfs, #3216
+  - clarify create --stats duration vs. wall time, #3301
+  - clarify encrypted key format for borg key export, #3296
+  - update release checklist about security fixes
+  - document good and problematic option placements, fix examples, #3356
+  - add note about using --nobsdflags to avoid speed penalty related to
+    bsdflags, #3239
+  - move most of support section to www.borgbackup.org
+
+
+Version 1.1.2 (2017-11-05)
+--------------------------
+
+Fixes:
+
+- fix KeyError crash when talking to borg server < 1.0.7, #3244
+- extract: set bsdflags last (include immutable flag), #3263
+- create: don't do stat() call on excluded-norecurse directory, fix exception
+  handling for stat() call, #3209
+- create --stats: do not count data volume twice when checkpointing, #3224
+- recreate: move chunks_healthy when excluding hardlink master, #3228
+- recreate: get rid of chunks_healthy when rechunking (does not match), #3218
+- check: get rid of already existing not matching chunks_healthy metadata, #3218
+- list: fix stdout broken pipe handling, #3245
+- list/diff: remove tag-file options (not used), #3226
+
+New features:
+
+- bash, zsh and fish shell auto-completions, see scripts/shell_completions/
+- added BORG_CONFIG_DIR env var, #3083
+
+Other changes:
+
+- docs:
+
+  - clarify using a blank passphrase in keyfile mode
+  - mention "!" (exclude-norecurse) type in "patterns" help
+  - document to first heal before running borg recreate to re-chunk stuff,
+    because that will have to get rid of chunks_healthy metadata.
+  - more than 23 is not supported for CHUNK_MAX_EXP, #3115
+  - borg does not respect nodump flag by default any more
+  - clarify same-filesystem requirement for borg upgrade, #2083
+  - update / rephrase cygwin / WSL status, #3174
+  - improve docs about --stats, #3260
+- vagrant: openindiana new clang package
+
+Already contained in 1.1.1 (last minute fix):
+
+- arg parsing: fix fallback function, refactor, #3205. This is a fixup
+  for #3155, which was broken on at least python <= 3.4.2.
+
+
+Version 1.1.1 (2017-10-22)
+--------------------------
+
+Compatibility notes:
+
+- The deprecated --no-files-cache is not a global/common option any more,
+  but only available for borg create (it is not needed for anything else).
+  Use --files-cache=disabled instead of --no-files-cache.
+- The nodump flag ("do not backup this file") is not honoured any more by
+  default because this functionality (esp. if it happened by error or
+  unexpected) was rather confusing and unexplainable at first to users.
+  If you want that "do not backup NODUMP-flagged files" behaviour, use:
+  borg create --exclude-nodump ...
+- If you are on Linux and do not need bsdflags archived, consider using
+  ``--nobsdflags`` with ``borg create`` to avoid additional syscalls and
+  speed up backup creation.
+
+Fixes:
+
+- borg recreate: correctly compute part file sizes. fixes cosmetic, but
+  annoying issue as borg check complains about size inconsistencies of part
+  files in affected archives. you can solve that by running borg recreate on
+  these archives, see also #3157.
+- bsdflags support: do not open BLK/CHR/LNK files, avoid crashes and
+  slowness, #3130
+- recreate: don't crash on attic archives w/o time_end, #3109
+- don't crash on repository filesystems w/o hardlink support, #3107
+- don't crash in first part of truncate_and_unlink, #3117
+- fix server-side IndexError crash with clients < 1.0.7, #3192
+- don't show traceback if only a global option is given, show help, #3142
+- cache: use SaveFile for more safety, #3158
+- init: fix wrong encryption choices in command line parser, fix missing
+  "authenticated-blake2", #3103
+- move --no-files-cache from common to borg create options, #3146
+- fix detection of non-local path (failed on ..filename), #3108
+- logging with fileConfig: set json attr on "borg" logger, #3114
+- fix crash with relative BORG_KEY_FILE, #3197
+- show excluded dir with "x" for tagged dirs / caches, #3189
+
+New features:
+
+- create: --nobsdflags and --exclude-nodump options, #3160
+- extract: --nobsdflags option, #3160
+
+Other changes:
+
+- remove annoying hardlinked symlinks warning, #3175
+- vagrant: use self-made FreeBSD 10.3 box, #3022
+- travis: don't brew update, hopefully fixes #2532
+- docs:
+
+  - readme: -e option is required in borg 1.1
+  - add example showing --show-version --show-rc
+  - use --format rather than --list-format (deprecated) in example
+  - update docs about hardlinked symlinks limitation
+
+
+Version 1.1.0 (2017-10-07)
+--------------------------
+
+Compatibility notes:
+
+- borg command line: do not put options in between positional arguments
+
+  This sometimes works (e.g. it worked in borg 1.0.x), but can easily stop
+  working if we make positional arguments optional (like it happened for
+  borg create's "paths" argument in 1.1). There are also places in borg 1.0
+  where we do that, so it doesn't work there in general either. #3356
+
+  Good: borg create -v --stats repo::archive path
+  Good: borg create repo::archive path -v --stats
+  Bad:  borg create repo::archive -v --stats path
+
+Fixes:
+
+- fix LD_LIBRARY_PATH restoration for subprocesses, #3077
+- "auto" compression: make sure expensive compression is actually better,
+  otherwise store lz4 compressed data we already computed.
+
+Other changes:
+
+- docs:
+
+  - FAQ: we do not implement futile attempts of ETA / progress displays
+  - manpage: fix typos, update homepage
+  - implement simple "issue" role for manpage generation, #3075
+
+
+Version 1.1.0rc4 (2017-10-01)
+-----------------------------
+
+Compatibility notes:
+
+- A borg server >= 1.1.0rc4 does not support borg clients 1.1.0b3-b5. #3033
+- The files cache is now controlled differently and has a new default mode:
+
+  - the files cache now uses ctime by default for improved file change
+    detection safety. You can still use mtime for more speed and less safety.
+  - --ignore-inode is deprecated (use --files-cache=... without "inode")
+  - --no-files-cache is deprecated (use --files-cache=disabled)
+
+New features:
+
+- --files-cache - implement files cache mode control, #911
+  You can now control the files cache mode using this option:
+  --files-cache={ctime,mtime,size,inode,rechunk,disabled}
+  (only some combinations are supported). See the docs for details.
+
+Fixes:
+
+- remote progress/logging: deal with partial lines, #2637
+- remote progress: flush json mode output
+- fix subprocess environments, #3050 (and more)
+
+Other changes:
+
+- remove client_supports_log_v3 flag, #3033
+- exclude broken Cython 0.27(.0) in requirements, #3066
+- vagrant:
+
+  - upgrade to FUSE for macOS 3.7.1
+  - use Python 3.5.4 to build the binaries
+- docs:
+
+  - security: change-passphrase only changes the passphrase, #2990
+  - fixed/improved borg create --compression examples, #3034
+  - add note about metadata dedup and --no[ac]time, #2518
+  - twitter account @borgbackup now, better visible, #2948
+  - simplified rate limiting wrapper in FAQ
+
+
+Version 1.1.0rc3 (2017-09-10)
+-----------------------------
+
+New features:
+
+- delete: support naming multiple archives, #2958
+
+Fixes:
+
+- repo cleanup/write: invalidate cached FDs, #2982
+- fix datetime.isoformat() microseconds issues, #2994
+- recover_segment: use mmap(), lower memory needs, #2987
+
+Other changes:
+
+- with-lock: close segment file before invoking subprocess
+- keymanager: don't depend on optional readline module, #2976
+- docs:
+
+  - fix macOS keychain integration command
+  - show/link new screencasts in README, #2936
+  - document utf-8 locale requirement for json mode, #2273
+- vagrant: clean up shell profile init, user name, #2977
+- test_detect_attic_repo: don't test mount, #2975
+- add debug logging for repository cleanup
+
+
+Version 1.1.0rc2 (2017-08-28)
+-----------------------------
+
+Compatibility notes:
+
+- list: corrected mix-up of "isomtime" and "mtime" formats. Previously,
+  "isomtime" was the default but produced a verbose human format,
+  while "mtime" produced a ISO-8601-like format.
+  The behaviours have been swapped (so "mtime" is human, "isomtime" is ISO-like),
+  and the default is now "mtime".
+  "isomtime" is now a real ISO-8601 format ("T" between date and time, not a space).
+
+New features:
+
+- None.
+
+Fixes:
+
+- list: fix weird mixup of mtime/isomtime
+- create --timestamp: set start time, #2957
+- ignore corrupt files cache, #2939
+- migrate locks to child PID when daemonize is used
+- fix exitcode of borg serve, #2910
+- only compare contents when chunker params match, #2899
+- umount: try fusermount, then try umount, #2863
+
+Other changes:
+
+- JSON: use a more standard ISO 8601 datetime format, #2376
+- cache: write_archive_index: truncate_and_unlink on error, #2628
+- detect non-upgraded Attic repositories, #1933
+- delete various nogil and threading related lines
+- coala / pylint related improvements
+- docs:
+
+  - renew asciinema/screencasts, #669
+  - create: document exclusion through nodump, #2949
+  - minor formatting fixes
+  - tar: tarpipe example
+  - improve "with-lock" and "info" docs, #2869
+  - detail how to use macOS/GNOME/KDE keyrings for repo passwords, #392
+- travis: only short-circuit docs-only changes for pull requests
+- vagrant:
+
+  - netbsd: bash is already installed
+  - fix netbsd version in PKG_PATH
+  - add exe location to PATH when we build an exe
+
+
+Version 1.1.0rc1 (2017-07-24)
+-----------------------------
+
+Compatibility notes:
+
+- delete: removed short option for --cache-only
+
+New features:
+
+- support borg list repo --format {comment} {bcomment} {end}, #2081
+- key import: allow reading from stdin, #2760
+
+Fixes:
+
+- with-lock: avoid creating segment files that might be overwritten later, #1867
+- prune: fix checkpoints processing with --glob-archives
+- FUSE: versions view: keep original file extension at end, #2769
+- fix --last, --first: do not accept values <= 0,
+  fix reversed archive ordering with --last
+- include testsuite data (attic.tar.gz) when installing the package
+- use limited unpacker for outer key, for manifest (both security precautions),
+  #2174 #2175
+- fix bashism in shell scripts, #2820, #2816
+- cleanup endianness detection, create _endian.h,
+  fixes build on alpine linux, #2809
+- fix crash with --no-cache-sync (give known chunk size to chunk_incref), #2853
+
+Other changes:
+
+- FUSE: versions view: linear numbering by archive time
+- split up interval parsing from filtering for --keep-within, #2610
+- add a basic .editorconfig, #2734
+- use archive creation time as mtime for FUSE mount, #2834
+- upgrade FUSE for macOS (osxfuse) from 3.5.8 to 3.6.3, #2706
+- hashindex: speed up by replacing modulo with "if" to check for wraparound
+- coala checker / pylint: fixed requirements and .coafile, more ignores
+- borg upgrade: name backup directories as 'before-upgrade', #2811
+- add .mailmap
+- some minor changes suggested by lgtm.com
+- docs:
+
+  - better explanation of the --ignore-inode option relevance, #2800
+  - fix openSUSE command and add openSUSE section
+  - simplify ssh authorized_keys file using "restrict", add legacy note, #2121
+  - mount: show usage of archive filters
+  - mount: add repository example, #2462
+  - info: update and add examples, #2765
+  - prune: include example
+  - improved style / formatting
+  - improved/fixed segments_per_dir docs
+  - recreate: fix wrong "remove unwanted files" example
+  - reference list of status chars in borg recreate --filter description
+  - update source-install docs about doc build dependencies, #2795
+  - cleanup installation docs
+  - file system requirements, update segs per dir
+  - fix checkpoints/parts reference in FAQ, #2859
+- code:
+
+  - hashindex: don't pass side effect into macro
+  - crypto low_level: don't mutate local bytes()
+  - use dash_open function to open file or "-" for stdin/stdout
+  - archiver: argparse cleanup / refactoring
+  - shellpattern: add match_end arg
+- tests: added some additional unit tests, some fixes, #2700 #2710
+- vagrant: fix setup of cygwin, add Debian 9 "stretch"
+- travis: don't perform full travis build on docs-only changes, #2531
+
+
+Version 1.1.0b6 (2017-06-18)
+----------------------------
+
+Compatibility notes:
+
+- Running "borg init" via a "borg serve --append-only" server will *not* create
+  an append-only repository anymore. Use "borg init --append-only" to initialize
+  an append-only repository.
+
+- Repositories in the "repokey" and "repokey-blake2" modes with an empty passphrase
+  are now treated as unencrypted repositories for security checks (e.g.
+  BORG_UNKNOWN_UNENCRYPTED_REPO_ACCESS_IS_OK).
+
+  Previously there would be no prompts nor messages if an unknown repository
+  in one of these modes with an empty passphrase was encountered. This would
+  allow an attacker to swap a repository, if one assumed that the lack of
+  password prompts was due to a set BORG_PASSPHRASE.
+
+  Since the "trick" does not work if BORG_PASSPHRASE is set, this does generally
+  not affect scripts.
+
+- Repositories in the "authenticated" mode are now treated as the unencrypted
+  repositories they are.
+
+- The client-side temporary repository cache now holds unencrypted data for better speed.
+
+- borg init: removed the short form of --append-only (-a).
+
+- borg upgrade: removed the short form of --inplace (-i).
+
+New features:
+
+- reimplemented the RepositoryCache, size-limited caching of decrypted repo
+  contents, integrity checked via xxh64. #2515
+- reduced space usage of chunks.archive.d. Existing caches are migrated during
+  a cache sync. #235 #2638
+- integrity checking using xxh64 for important files used by borg, #1101:
+
+  - repository: index and hints files
+  - cache: chunks and files caches, chunks.archive.d
+- improve cache sync speed, #1729
+- create: new --no-cache-sync option
+- add repository mandatory feature flags infrastructure, #1806
+- Verify most operations against SecurityManager. Location, manifest timestamp
+  and key types are now checked for almost all non-debug commands. #2487
+- implement storage quotas, #2517
+- serve: add --restrict-to-repository, #2589
+- BORG_PASSCOMMAND: use external tool providing the key passphrase, #2573
+- borg export-tar, #2519
+- list: --json-lines instead of --json for archive contents, #2439
+- add --debug-profile option (and also "borg debug convert-profile"), #2473
+- implement --glob-archives/-a, #2448
+- normalize authenticated key modes for better naming consistency:
+
+  - rename "authenticated" to "authenticated-blake2" (uses blake2b)
+  - implement "authenticated" mode (uses hmac-sha256)
+
+Fixes:
+
+- hashindex: read/write indices >2 GiB on 32bit systems, better error
+  reporting, #2496
+- repository URLs: implement IPv6 address support and also more informative
+  error message when parsing fails.
+- mount: check whether llfuse is installed before asking for passphrase, #2540
+- mount: do pre-mount checks before opening repository, #2541
+- FUSE:
+
+  - fix crash if empty (None) xattr is read, #2534
+  - fix read(2) caching data in metadata cache
+  - fix negative uid/gid crash (fix crash when mounting archives
+    of external drives made on cygwin), #2674
+  - redo ItemCache, on top of object cache
+  - use decrypted cache
+  - remove unnecessary normpaths
+- serve: ignore --append-only when initializing a repository (borg init), #2501
+- serve: fix incorrect type of exception_short for Errors, #2513
+- fix --exclude and --exclude-from recursing into directories, #2469
+- init: don't allow creating nested repositories, #2563
+- --json: fix encryption[mode] not being the cmdline name
+- remote: propagate Error.traceback correctly
+- fix remote logging and progress, #2241
+
+  - implement --debug-topic for remote servers
+  - remote: restore "Remote:" prefix (as used in 1.0.x)
+  - rpc negotiate: enable v3 log protocol only for supported clients
+  - fix --progress and logging in general for remote
+- fix parse_version, add tests, #2556
+- repository: truncate segments (and also some other files) before unlinking, #2557
+- recreate: keep timestamps as in original archive, #2384
+- recreate: if single archive is not processed, exit 2
+- patterns: don't recurse with ! / --exclude for pf:, #2509
+- cache sync: fix n^2 behaviour in lookup_name
+- extract: don't write to disk with --stdout (affected non-regular-file items), #2645
+- hashindex: implement KeyError, more tests
+
+Other changes:
+
+- remote: show path in PathNotAllowed
+- consider repokey w/o passphrase == unencrypted, #2169
+- consider authenticated mode == unencrypted, #2503
+- restrict key file names, #2560
+- document follow_symlinks requirements, check libc, use stat and chown
+  with follow_symlinks=False, #2507
+- support common options on the main command, #2508
+- support common options on mid-level commands (e.g. borg *key* export)
+- make --progress a common option
+- increase DEFAULT_SEGMENTS_PER_DIR to 1000
+- chunker: fix invalid use of types (function only used by tests)
+- chunker: don't do uint32_t >> 32
+- FUSE:
+
+  - add instrumentation (--debug and SIGUSR1/SIGINFO)
+  - reduced memory usage for repository mounts by lazily instantiating archives
+  - improved archive load times
+- info: use CacheSynchronizer & HashIndex.stats_against (better performance)
+- docs:
+
+  - init: document --encryption as required
+  - security: OpenSSL usage
+  - security: used implementations; note python libraries
+  - security: security track record of OpenSSL and msgpack
+  - patterns: document denial of service (regex, wildcards)
+  - init: note possible denial of service with "none" mode
+  - init: document SHA extension is supported in OpenSSL and thus SHA is
+    faster on AMD Ryzen than blake2b.
+  - book: use A4 format, new builder option format.
+  - book: create appendices
+  - data structures: explain repository compaction
+  - data structures: add chunk layout diagram
+  - data structures: integrity checking
+  - data structures: demingle cache and repo index
+  - Attic FAQ: separate section for attic stuff
+  - FAQ: I get an IntegrityError or similar - what now?
+  - FAQ: Can I use Borg on SMR hard drives?, #2252
+  - FAQ: specify "using inline shell scripts"
+  - add systemd warning regarding placeholders, #2543
+  - xattr: document API
+  - add docs/misc/borg-data-flow data flow chart
+  - debugging facilities
+  - README: how to help the project, #2550
+  - README: add bountysource badge, #2558
+  - fresh new theme + tweaking
+  - logo: vectorized (PDF and SVG) versions
+  - frontends: use headlines - you can link to them
+  - mark --pattern, --patterns-from as experimental
+  - highlight experimental features in online docs
+  - remove regex based pattern examples, #2458
+  - nanorst for "borg help TOPIC" and --help
+  - split deployment
+  - deployment: hosting repositories
+  - deployment: automated backups to a local hard drive
+  - development: vagrant, windows10 requirements
+  - development: update docs remarks
+  - split usage docs, #2627
+  - usage: avoid bash highlight, [options] instead of <options>
+  - usage: add benchmark page
+  - helpers: truncate_and_unlink doc
+  - don't suggest to leak BORG_PASSPHRASE
+  - internals: columnize rather long ToC [webkit fixup]
+    internals: manifest & feature flags
+  - internals: more HashIndex details
+  - internals: fix ASCII art equations
+  - internals: edited obj graph related sections a bit
+  - internals: layers image + description
+  - fix way too small figures in pdf
+  - index: disable syntax highlight (bash)
+  - improve options formatting, fix accidental block quotes
+
+- testing / checking:
+
+  - add support for using coala, #1366
+  - testsuite: add ArchiverCorruptionTestCase
+  - do not test logger name, #2504
+  - call setup_logging after destroying logging config
+  - testsuite.archiver: normalise pytest.raises vs. assert_raises
+  - add test for preserved intermediate folder permissions, #2477
+  - key: add round-trip test
+  - remove attic dependency of the tests, #2505
+  - enable remote tests on cygwin
+  - tests: suppress tar's future timestamp warning
+  - cache sync: add more refcount tests
+  - repository: add tests, including corruption tests
+
+- vagrant:
+
+  - control VM cpus and pytest workers via env vars VMCPUS and XDISTN
+  - update cleaning workdir
+  - fix openbsd shell
+  - add OpenIndiana
+
+- packaging:
+
+  - binaries: don't bundle libssl
+  - setup.py clean to remove compiled files
+  - fail in borg package if version metadata is very broken (setuptools_scm)
+
+- repo / code structure:
+
+  - create borg.algorithms and borg.crypto packages
+  - algorithms: rename crc32 to checksums
+  - move patterns to module, #2469
+  - gitignore: complete paths for src/ excludes
+  - cache: extract CacheConfig class
+  - implement IntegrityCheckedFile + Detached variant, #2502 #1688
+  - introduce popen_with_error_handling to handle common user errors
+
+
+Version 1.1.0b5 (2017-04-30)
+----------------------------
+
+Compatibility notes:
+
+- BORG_HOSTNAME_IS_UNIQUE is now on by default.
+- removed --compression-from feature
+- recreate: add --recompress flag, unify --always-recompress and
+  --recompress
+
+Fixes:
+
+- catch exception for os.link when hardlinks are not supported, #2405
+- borg rename / recreate: expand placeholders, #2386
+- generic support for hardlinks (files, devices, FIFOs), #2324
+- extract: also create parent dir for device files, if needed, #2358
+- extract: if a hardlink master is not in the to-be-extracted subset,
+  the "x" status was not displayed for it, #2351
+- embrace y2038 issue to support 32bit platforms: clamp timestamps to int32,
+  #2347
+- verify_data: fix IntegrityError handling for defect chunks, #2442
+- allow excluding parent and including child, #2314
+
+Other changes:
+
+- refactor compression decision stuff
+- change global compression default to lz4 as well, to be consistent
+  with --compression defaults.
+- placeholders: deny access to internals and other unspecified stuff
+- clearer error message for unrecognized placeholder
+- more clear exception if borg check does not help, #2427
+- vagrant: upgrade FUSE for macOS to 3.5.8, #2346
+- linux binary builds: get rid of glibc 2.13 dependency, #2430
+- docs:
+
+  - placeholders: document escaping
+  - serve: env vars in original commands are ignored
+  - tell what kind of hardlinks we support
+  - more docs about compression
+  - LICENSE: use canonical formulation
+    ("copyright holders and contributors" instead of "author")
+  - document borg init behaviour via append-only borg serve, #2440
+  - be clear about what buzhash is used for, #2390
+  - add hint about chunker params, #2421
+  - clarify borg upgrade docs, #2436
+  - FAQ to explain warning when running borg check --repair, #2341
+  - repository file system requirements, #2080
+  - pre-install considerations
+  - misc. formatting / crossref fixes
+- tests:
+
+  - enhance travis setuptools_scm situation
+  - add extra test for the hashindex
+  - fix invalid param issue in benchmarks
+
+These belong to 1.1.0b4 release, but did not make it into changelog by then:
+
+- vagrant: increase memory for parallel testing
+- lz4 compress: lower max. buffer size, exception handling
+- add docstring to do_benchmark_crud
+- patterns help: mention path full-match in intro
+
+
+Version 1.1.0b4 (2017-03-27)
+----------------------------
+
+Compatibility notes:
+
+- init: the --encryption argument is mandatory now (there are several choices)
+- moved "borg migrate-to-repokey" to "borg key migrate-to-repokey".
+- "borg change-passphrase" is deprecated, use "borg key change-passphrase"
+  instead.
+- the --exclude-if-present option now supports tagging a folder with any
+  filesystem object type (file, folder, etc), instead of expecting only files
+  as tags, #1999
+- the --keep-tag-files option has been deprecated in favor of the new
+  --keep-exclude-tags, to account for the change mentioned above.
+- use lz4 compression by default, #2179
+
+New features:
+
+- JSON API to make developing frontends and automation easier
+  (see :ref:`json_output`)
+
+  - add JSON output to commands: `borg create/list/info --json ...`.
+  - add --log-json option for structured logging output.
+  - add JSON progress information, JSON support for confirmations (yes()).
+- add two new options --pattern and --patterns-from as discussed in #1406
+- new path full match pattern style (pf:) for very fast matching, #2334
+- add 'debug dump-manifest' and 'debug dump-archive' commands
+- add 'borg benchmark crud' command, #1788
+- new 'borg delete --force --force' to delete severely corrupted archives, #1975
+- info: show utilization of maximum archive size, #1452
+- list: add dsize and dcsize keys, #2164
+- paperkey.html: Add interactive html template for printing key backups.
+- key export: add qr html export mode
+- securely erase config file (which might have old encryption key), #2257
+- archived file items: add size to metadata, 'borg extract' and 'borg check' do
+  check the file size for consistency, FUSE uses precomputed size from Item.
+
+Fixes:
+
+- fix remote speed regression introduced in 1.1.0b3, #2185
+- fix regression handling timestamps beyond 2262 (revert bigint removal),
+  introduced in 1.1.0b3, #2321
+- clamp (nano)second values to unproblematic range, #2304
+- hashindex: rebuild hashtable if we have too little empty buckets
+  (performance fix), #2246
+- Location regex: fix bad parsing of wrong syntax
+- ignore posix_fadvise errors in repository.py, #2095
+- borg rpc: use limited msgpack.Unpacker (security precaution), #2139
+- Manifest: Make sure manifest timestamp is strictly monotonically increasing.
+- create: handle BackupOSError on a per-path level in one spot
+- create: clarify -x option / meaning of "same filesystem"
+- create: don't create hard link refs to failed files
+- archive check: detect and fix missing all-zero replacement chunks, #2180
+- files cache: update inode number when --ignore-inode is used, #2226
+- fix decompression exceptions crashing ``check --verify-data`` and others
+  instead of reporting integrity error, #2224 #2221
+- extract: warning for unextracted big extended attributes, #2258, #2161
+- mount: umount on SIGINT/^C when in foreground
+- mount: handle invalid hard link refs
+- mount: fix huge RAM consumption when mounting a repository (saves number of
+  archives * 8 MiB), #2308
+- hashindex: detect mingw byte order #2073
+- hashindex: fix wrong skip_hint on hashindex_set when encountering tombstones,
+  the regression was introduced in #1748
+- fix ChunkIndex.__contains__ assertion  for big-endian archs
+- fix borg key/debug/benchmark crashing without subcommand, #2240
+- Location: accept //servername/share/path
+- correct/refactor calculation of unique/non-unique chunks
+- extract: fix missing call to ProgressIndicator.finish
+- prune: fix error msg, it is --keep-within, not --within
+- fix "auto" compression mode bug (not compressing), #2331
+- fix symlink item fs size computation, #2344
+
+Other changes:
+
+- remote repository: improved async exception processing, #2255 #2225
+- with --compression auto,C, only use C if lz4 achieves at least 3% compression
+- PatternMatcher: only normalize path once, #2338
+- hashindex: separate endian-dependent defs from endian detection
+- migrate-to-repokey: ask using canonical_path() as we do everywhere else.
+- SyncFile: fix use of fd object after close
+- make LoggedIO.close_segment reentrant
+- creating a new segment: use "xb" mode, #2099
+- redo key_creator, key_factory, centralise key knowledge, #2272
+- add return code functions, #2199
+- list: only load cache if needed
+- list: files->items, clarifications
+- list: add "name" key for consistency with info cmd
+- ArchiveFormatter: add "start" key for compatibility with "info"
+- RemoteRepository: account rx/tx bytes
+- setup.py build_usage/build_man/build_api fixes
+- Manifest.in: simplify, exclude .so, .dll and .orig, #2066
+- FUSE: get rid of chunk accounting, st_blocks = ceil(size / blocksize).
+- tests:
+
+  - help python development by testing 3.6-dev
+  - test for borg delete --force
+- vagrant:
+
+  - freebsd: some fixes, #2067
+  - darwin64: use osxfuse 3.5.4 for tests / to build binaries
+  - darwin64: improve VM settings
+  - use python 3.5.3 to build binaries, #2078
+  - upgrade pyinstaller from 3.1.1+ to 3.2.1
+  - pyinstaller: use fixed AND freshly compiled bootloader, #2002
+  - pyinstaller: automatically builds bootloader if missing
+- docs:
+
+  - create really nice man pages
+  - faq: mention --remote-ratelimit in bandwidth limit question
+  - fix caskroom link, #2299
+  - docs/security: reiterate that RPC in Borg does no networking
+  - docs/security: counter tracking, #2266
+  - docs/development: update merge remarks
+  - address SSH batch mode in docs, #2202 #2270
+  - add warning about running build_usage on Python >3.4, #2123
+  - one link per distro in the installation page
+  - improve --exclude-if-present and --keep-exclude-tags, #2268
+  - improve automated backup script in doc, #2214
+  - improve remote-path description
+  - update docs for create -C default change (lz4)
+  - document relative path usage, #1868
+  - document snapshot usage, #2178
+  - corrected some stuff in internals+security
+  - internals: move toctree to after the introduction text
+  - clarify metadata kind, manifest ops
+  - key enc: correct / clarify some stuff, link to internals/security
+  - datas: enc: 1.1.x mas different MACs
+  - datas: enc: correct factual error -- no nonce involved there.
+  - make internals.rst an index page and edit it a bit
+  - add "Cryptography in Borg" and "Remote RPC protocol security" sections
+  - document BORG_HOSTNAME_IS_UNIQUE, #2087
+  - FAQ by categories as proposed by @anarcat in #1802
+  - FAQ: update Which file types, attributes, etc. are *not* preserved?
+  - development: new branching model for git repository
+  - development: define "ours" merge strategy for auto-generated files
+  - create: move --exclude note to main doc
+  - create: move item flags to main doc
+  - fix examples using borg init without -e/--encryption
+  - list: don't print key listings in fat (html + man)
+  - remove Python API docs (were very incomplete, build problems on RTFD)
+  - added FAQ section about backing up root partition
+
+
+Version 1.1.0b3 (2017-01-15)
+----------------------------
+
+Compatibility notes:
+
+- borg init: removed the default of "--encryption/-e", #1979
+  This was done so users do a informed decision about -e mode.
+
+Bug fixes:
+
+- borg recreate: don't rechunkify unless explicitly told so
+- borg info: fixed bug when called without arguments, #1914
+- borg init: fix free space check crashing if disk is full, #1821
+- borg debug delete/get obj: fix wrong reference to exception
+- fix processing of remote ~/ and ~user/ paths (regressed since 1.1.0b1), #1759
+- posix platform module: only build / import on non-win32 platforms, #2041
+
+New features:
+
+- new CRC32 implementations that are much faster than the zlib one used previously, #1970
+- add blake2b key modes (use blake2b as MAC). This links against system libb2,
+  if possible, otherwise uses bundled code
+- automatically remove stale locks - set BORG_HOSTNAME_IS_UNIQUE env var
+  to enable stale lock killing. If set, stale locks in both cache and
+  repository are deleted. #562 #1253
+- borg info <repo>: print general repo information, #1680
+- borg check --first / --last / --sort / --prefix, #1663
+- borg mount --first / --last / --sort / --prefix, #1542
+- implement "health" item formatter key, #1749
+- BORG_SECURITY_DIR to remember security related infos outside the cache.
+  Key type, location and manifest timestamp checks now survive cache
+  deletion. This also means that you can now delete your cache and avoid
+  previous warnings, since Borg can still tell it's safe.
+- implement BORG_NEW_PASSPHRASE, #1768
+
+Other changes:
+
+- borg recreate:
+
+  - remove special-cased --dry-run
+  - update --help
+  - remove bloat: interruption blah, autocommit blah, resuming blah
+  - re-use existing checkpoint functionality
+  - archiver tests: add check_cache tool - lints refcounts
+
+- fixed cache sync performance regression from 1.1.0b1 onwards, #1940
+- syncing the cache without chunks.archive.d (see :ref:`disable_archive_chunks`)
+  now avoids any merges and is thus faster, #1940
+- borg check --verify-data: faster due to linear on-disk-order scan
+- borg debug-xxx commands removed, we use "debug xxx" subcommands now, #1627
+- improve metadata handling speed
+- shortcut hashindex_set by having hashindex_lookup hint about address
+- improve / add progress displays, #1721
+- check for index vs. segment files object count mismatch
+- make RPC protocol more extensible: use named parameters.
+- RemoteRepository: misc. code cleanups / refactors
+- clarify cache/repository README file
+
+- docs:
+
+  - quickstart: add a comment about other (remote) filesystems
+  - quickstart: only give one possible ssh url syntax, all others are
+    documented in usage chapter.
+  - mention file://
+  - document repo URLs / archive location
+  - clarify borg diff help, #980
+  - deployment: synthesize alternative --restrict-to-path example
+  - improve cache / index docs, esp. files cache docs, #1825
+  - document using "git merge 1.0-maint -s recursive -X rename-threshold=20%"
+    for avoiding troubles when merging the 1.0-maint branch into master.
+
+- tests:
+
+  - FUSE tests: catch ENOTSUP on freebsd
+  - FUSE tests: test troublesome xattrs last
+  - fix byte range error in test, #1740
+  - use monkeypatch to set env vars, but only on pytest based tests.
+  - point XDG_*_HOME to temp dirs for tests, #1714
+  - remove all BORG_* env vars from the outer environment
+
+
+Version 1.1.0b2 (2016-10-01)
+----------------------------
+
+Bug fixes:
+
+- fix incorrect preservation of delete tags, leading to "object count mismatch"
+  on borg check, #1598. This only occurred with 1.1.0b1 (not with 1.0.x) and is
+  normally fixed by running another borg create/delete/prune.
+- fix broken --progress for double-cell paths (e.g. CJK), #1624
+- borg recreate: also catch SIGHUP
+- FUSE:
+
+  - fix hardlinks in versions view, #1599
+  - add parameter check to ItemCache.get to make potential failures more clear
+
+New features:
+
+- Archiver, RemoteRepository: add --remote-ratelimit (send data)
+- borg help compression, #1582
+- borg check: delete chunks with integrity errors, #1575, so they can be
+  "repaired" immediately and maybe healed later.
+- archives filters concept (refactoring/unifying older code)
+
+  - covers --first/--last/--prefix/--sort-by options
+  - currently used for borg list/info/delete
+
+Other changes:
+
+- borg check --verify-data slightly tuned (use get_many())
+- change {utcnow} and {now} to ISO-8601 format ("T" date/time separator)
+- repo check: log transaction IDs, improve object count mismatch diagnostic
+- Vagrantfile: use TW's fresh-bootloader pyinstaller branch
+- fix module names in api.rst
+- hashindex: bump api_version
+
+
+Version 1.1.0b1 (2016-08-28)
+----------------------------
+
+New features:
+
+- new commands:
+
+  - borg recreate: re-create existing archives, #787 #686 #630 #70, also see
+    #757, #770.
+
+    - selectively remove files/dirs from old archives
+    - re-compress data
+    - re-chunkify data, e.g. to have upgraded Attic / Borg 0.xx archives
+      deduplicate with Borg 1.x archives or to experiment with chunker-params.
+  - borg diff: show differences between archives
+  - borg with-lock: execute a command with the repository locked, #990
+- borg create:
+
+  - Flexible compression with pattern matching on path/filename,
+    and LZ4 heuristic for deciding compressibility, #810, #1007
+  - visit files in inode order (better speed, esp. for large directories and rotating disks)
+  - in-file checkpoints, #1217
+  - increased default checkpoint interval to 30 minutes (was 5 minutes), #896
+  - added uuid archive format tag, #1151
+  - save mountpoint directories with --one-file-system, makes system restore easier, #1033
+  - Linux: added support for some BSD flags, #1050
+  - add 'x' status for excluded paths, #814
+
+    - also means files excluded via UF_NODUMP, #1080
+- borg check:
+
+  - will not produce the "Checking segments" output unless new --progress option is passed, #824.
+  - --verify-data to verify data cryptographically on the client, #975
+- borg list, #751, #1179
+
+  - removed {formatkeys}, see "borg list --help"
+  - --list-format is deprecated, use --format instead
+  - --format now also applies to listing archives, not only archive contents, #1179
+  - now supports the usual [PATH [PATHS…]] syntax and excludes
+  - new keys: csize, num_chunks, unique_chunks, NUL
+  - supports guaranteed_available hashlib hashes
+    (to avoid varying functionality depending on environment),
+    which includes the SHA1 and SHA2 family as well as MD5
+- borg prune:
+
+  - to better visualize the "thinning out", we now list all archives in
+    reverse time order. rephrase and reorder help text.
+  - implement --keep-last N via --keep-secondly N, also --keep-minutely.
+    assuming that there is not more than 1 backup archive made in 1s,
+    --keep-last N and --keep-secondly N are equivalent, #537
+  - cleanup checkpoints except the latest, #1008
+- borg extract:
+
+  - added --progress, #1449
+  - Linux: limited support for BSD flags, #1050
+- borg info:
+
+  - output is now more similar to borg create --stats, #977
+- borg mount:
+
+  - provide "borgfs" wrapper for borg mount, enables usage via fstab, #743
+  - "versions" mount option - when used with a repository mount, this gives
+    a merged, versioned view of the files in all archives, #729
+- repository:
+
+  - added progress information to commit/compaction phase (often takes some time when deleting/pruning), #1519
+  - automatic recovery for some forms of repository inconsistency, #858
+  - check free space before going forward with a commit, #1336
+  - improved write performance (esp. for rotating media), #985
+
+    - new IO code for Linux
+    - raised default segment size to approx 512 MiB
+  - improved compaction performance, #1041
+  - reduced client CPU load and improved performance for remote repositories, #940
+
+- options that imply output (--show-rc, --show-version, --list, --stats,
+  --progress) don't need -v/--info to have that output displayed, #865
+- add archive comments (via borg (re)create --comment), #842
+- borg list/prune/delete: also output archive id, #731
+- --show-version: shows/logs the borg version, #725
+- added --debug-topic for granular debug logging, #1447
+- use atomic file writing/updating for configuration and key files, #1377
+- BORG_KEY_FILE environment variable, #1001
+- self-testing module, #970
+
+
+Bug fixes:
+
+- list: fixed default output being produced if --format is given with empty parameter, #1489
+- create: fixed overflowing progress line with CJK and similar characters, #1051
+- prune: fixed crash if --prefix resulted in no matches, #1029
+- init: clean up partial repo if passphrase input is aborted, #850
+- info: quote cmdline arguments that have spaces in them
+- fix hardlinks failing in some cases for extracting subtrees, #761
+
+Other changes:
+
+- replace stdlib hmac with OpenSSL, zero-copy decrypt (10-15% increase in
+  performance of hash-lists and extract).
+- improved chunker performance, #1021
+- open repository segment files in exclusive mode (fail-safe), #1134
+- improved error logging, #1440
+- Source:
+
+  - pass meta-data around, #765
+  - move some constants to new constants module
+  - better readability and fewer errors with namedtuples, #823
+  - moved source tree into src/ subdirectory, #1016
+  - made borg.platform a package, #1113
+  - removed dead crypto code, #1032
+  - improved and ported parts of the test suite to py.test, #912
+  - created data classes instead of passing dictionaries around, #981, #1158, #1161
+  - cleaned up imports, #1112
+- Docs:
+
+  - better help texts and sphinx reproduction of usage help:
+
+    - Group options
+    - Nicer list of options in Sphinx
+    - Deduplicate 'Common options' (including --help)
+  - chunker: added some insights by "Voltara", #903
+  - clarify what "deduplicated size" means
+  - fix / update / add package list entries
+  - added a SaltStack usage example, #956
+  - expanded FAQ
+  - new contributors in AUTHORS!
+- Tests:
+
+  - vagrant: add ubuntu/xenial 64bit - this box has still some issues
+  - ChunkBuffer: add test for leaving partial chunk in buffer, fixes #945
+
+
+Version 1.0.13 (2019-02-15)
+---------------------------
+
+Please note: this is very likely the last 1.0.x release, please upgrade to 1.1.x.
+
+Bug fixes:
+
+- security fix: configure FUSE with "default_permissions", #3903.
+  "default_permissions" is now enforced by borg by default to let the
+  kernel check uid/gid/mode based permissions.
+  "ignore_permissions" can be given to not enforce "default_permissions".
+- xattrs: fix borg exception handling on ENOSPC error, #3808.
+
+New features:
+
+- Read a passphrase from a file descriptor specified in the
+  BORG_PASSPHRASE_FD environment variable.
+
+Other changes:
+
+- acl platform code: fix acl set return type
+- xattr:
+
+  - add linux {list,get,set}xattr ctypes prototypes
+  - fix darwin flistxattr ctypes prototype
+- testing / travis-ci:
+
+  - fix the homebrew 1.9 issues on travis-ci, #4254
+  - travis OS X: use xcode 8.3 (not broken)
+  - tox.ini: lock requirements
+  - unbreak 1.0-maint on travis, fixes #4123
+- vagrant:
+
+  - misc. fixes
+  - FUSE for macOS: upgrade 3.7.1 to 3.8.3
+  - Python: upgrade 3.5.5 to 3.5.6
+- docs:
+
+  - Update installation instructions for macOS
+  - update release workflow using twine (docs, scripts), #4213
+
+Version 1.0.12 (2018-04-08)
+---------------------------
+
+Bug fixes:
+
+- repository: cleanup/write: invalidate cached FDs, tests
+- serve: fix exitcode, #2910
+- extract: set bsdflags last (include immutable flag), #3263
+- create --timestamp: set start time, #2957
+- create: show excluded dir with "x" for tagged dirs / caches, #3189
+- migrate locks to child PID when daemonize is used
+- Buffer: fix wrong thread-local storage use, #2951
+- fix detection of non-local path, #3108
+- fix LDLP restoration for subprocesses, #3077
+- fix subprocess environments (xattr module's fakeroot version check,
+  borg umount, BORG_PASSCOMMAND), #3050
+- remote: deal with partial lines, #2637
+- get rid of datetime.isoformat, use safe parse_timestamp to parse
+  timestamps, #2994
+- build: do .h file content checks in binary mode, fixes build issue for
+  non-ascii header files on pure-ascii locale platforms, #3544 #3639
+- remove platform.uname() call which caused library mismatch issues, #3732
+- add exception handler around deprecated platform.linux_distribution() call
+
+Other changes:
+
+- require msgpack-python >= 0.4.6 and < 0.5.0, see #3753
+- add parens for C preprocessor macro argument usages (did not cause
+  malfunction)
+- ignore corrupt files cache, #2939
+- replace "modulo" with "if" to check for wraparound in hashmap
+- keymanager: don't depend on optional readline module, #2980
+- exclude broken pytest 3.3.0 release
+- exclude broken Cython 0.27(.0) release, #3066
+- flake8: add some ignores
+- docs:
+
+  - create: document exclusion through nodump
+  - document good and problematic option placements, fix examples, #3356
+  - update docs about hardlinked symlinks limitation
+  - faq: we do not implement futile attempts of ETA / progress displays
+  - simplified rate limiting wrapper in FAQ
+  - twitter account @borgbackup, #2948
+  - add note about metadata dedup and --no[ac]time, #2518
+  - change-passphrase only changes the passphrase, #2990
+  - clarify encrypted key format for borg key export, #3296
+  - document sshfs rename workaround, #3315
+  - update release checklist about security fixes
+  - docs about how to verify a signed release, #3634
+  - chunk seed is generated per /repository/
+- vagrant:
+
+  - use FUSE for macOS 3.7.1 to build the macOS binary
+  - use python 3.5.5 to build the binaries
+  - add exe location to PATH when we build an exe
+  - use https pypi url for wheezy
+  - netbsd: bash is already installed
+  - netbsd: fix netbsd version in PKG_PATH
+  - use self-made FreeBSD 10.3 box, #3022
+  - backport fs_init (including related updates) from 1.1
+  - the boxcutter wheezy boxes are 404, use local ones
+- travis:
+
+  - don't perform full Travis build on docs-only changes, #2531
+  - only short-circuit docs-only changes for pull requests
+
+
+Version 1.0.11 (2017-07-21)
+---------------------------
+
+Bug fixes:
+
+- use limited unpacker for outer key (security precaution), #2174
+- fix paperkey import bug
+
+Other changes:
+
+- change --checkpoint-interval default from 600s to 1800s, #2841.
+  this improves efficiency for big repositories a lot.
+- docs: fix OpenSUSE command and add OpenSUSE section
+- tests: add tests for split_lstring and paperkey
+- vagrant:
+
+  - fix openbsd shell
+  - backport cpu/ram setup from master
+  - add stretch64 VM
+
+Version 1.0.11rc1 (2017-06-27)
+------------------------------
+
+Bug fixes:
+
+- performance: rebuild hashtable if we have too few empty buckets, #2246.
+  this fixes some sporadic, but severe performance breakdowns.
+- Archive: allocate zeros when needed, #2308
+  fixes huge memory usage of mount (8 MiB × number of archives)
+- IPv6 address support
+  also: Location: more informative exception when parsing fails
+- borg single-file binary: use pyinstaller v3.2.1, #2396
+  this fixes that the prelink cronjob on some distros kills the
+  borg binary by stripping away parts of it.
+- extract:
+
+  - warning for unextracted big extended attributes, #2258
+  - also create parent dir for device files, if needed.
+  - don't write to disk with --stdout, #2645
+- archive check: detect and fix missing all-zero replacement chunks, #2180
+- fix (de)compression exceptions, #2224 #2221
+- files cache: update inode number, #2226
+- borg rpc: use limited msgpack.Unpacker (security precaution), #2139
+- Manifest: use limited msgpack.Unpacker (security precaution), #2175
+- Location: accept //servername/share/path
+- fix ChunkIndex.__contains__ assertion  for big-endian archs (harmless)
+- create: handle BackupOSError on a per-path level in one spot
+- fix error msg, there is no --keep-last in borg 1.0.x, #2282
+- clamp (nano)second values to unproblematic range, #2304
+- fuse / borg mount:
+
+  - fix st_blocks to be an integer (not float) value
+  - fix negative uid/gid crash (they could come into archives e.g. when
+    backing up external drives under cygwin), #2674
+  - fix crash if empty (None) xattr is read
+  - do pre-mount checks before opening repository
+  - check llfuse is installed before asking for passphrase
+- borg rename: expand placeholders, #2386
+- borg serve: fix forced command lines containing BORG_* env vars
+- fix error msg, it is --keep-within, not --within
+- fix borg key/debug/benchmark crashing without subcommand, #2240
+- chunker: fix invalid use of types, don't do uint32_t >> 32
+- document follow_symlinks requirements, check libc, #2507
+
+New features:
+
+- added BORG_PASSCOMMAND environment variable, #2573
+- add minimal version of in repository mandatory feature flags, #2134
+
+  This should allow us to make sure older borg versions can be cleanly
+  prevented from doing operations that are no longer safe because of
+  repository format evolution. This allows more fine grained control than
+  just incrementing the manifest version. So for example a change that
+  still allows new archives to be created but would corrupt the repository
+  when an old version tries to delete an archive or check the repository
+  would add the new feature to the check and delete set but leave it out
+  of the write set.
+- borg delete --force --force to delete severely corrupted archives, #1975
+
+Other changes:
+
+- embrace y2038 issue to support 32bit platforms
+- be more clear that this is a "beyond repair" case, #2427
+- key file names: limit to 100 characters and remove colons from host name
+- upgrade FUSE for macOS to 3.5.8, #2346
+- split up parsing and filtering for --keep-within, better error message, #2610
+- docs:
+
+  - fix caskroom link, #2299
+  - address SSH batch mode, #2202 #2270
+  - improve remote-path description
+  - document snapshot usage, #2178
+  - document relative path usage, #1868
+  - one link per distro in the installation page
+  - development: new branching model in git repository
+  - kill api page
+  - added FAQ section about backing up root partition
+  - add bountysource badge, #2558
+  - create empty docs.txt reequirements, #2694
+  - README: how to help the project
+  - note -v/--verbose requirement on affected options, #2542
+  - document borg init behaviour via append-only borg serve, #2440
+  - be clear about what buzhash is used for (chunking) and want it is not
+    used for (deduplication)- also say already in the readme that we use a
+    cryptohash for dedupe, so people don't worry, #2390
+  - add hint about chunker params to borg upgrade docs, #2421
+  - clarify borg upgrade docs, #2436
+  - quickstart: delete problematic BORG_PASSPHRASE use, #2623
+  - faq: specify "using inline shell scripts"
+  - document pattern denial of service, #2624
+- tests:
+
+  - remove attic dependency of the tests, #2505
+  - travis:
+
+    - enhance travis setuptools_scm situation
+    - install fakeroot for Linux
+  - add test for borg delete --force
+  - enable remote tests on cygwin (the cygwin issue that caused these tests
+    to break was fixed in cygwin at least since cygwin 2.8, maybe even since
+    2.7.0).
+  - remove skipping the noatime tests on GNU/Hurd, #2710
+  - fix borg import issue, add comment, #2718
+  - include attic.tar.gz when installing the package
+    also: add include_package_data=True
+
+Version 1.0.10 (2017-02-13)
+---------------------------
+
+Bug fixes:
+
+- Manifest timestamps are now monotonically increasing,
+  this fixes issues when the system clock jumps backwards
+  or is set inconsistently across computers accessing the same repository, #2115
+- Fixed testing regression in 1.0.10rc1 that lead to a hard dependency on
+  py.test >= 3.0, #2112
+
+New features:
+
+- "key export" can now generate a printable HTML page with both a QR code and
+  a human-readable "paperkey" representation (and custom text) through the
+  ``--qr-html`` option.
+
+  The same functionality is also available through `paperkey.html <paperkey.html>`_,
+  which is the same HTML page generated by ``--qr-html``. It works with existing
+  "key export" files and key files.
+
+Other changes:
+
+- docs:
+
+  - language clarification - "borg create --one-file-system" option does not respect
+    mount points, but considers different file systems instead, #2141
+- setup.py: build_api: sort file list for determinism
+
+
+Version 1.0.10rc1 (2017-01-29)
+------------------------------
+
+Bug fixes:
+
+- borg serve: fix transmission data loss of pipe writes, #1268
+  This affects only the cygwin platform (not Linux, BSD, OS X).
+- Avoid triggering an ObjectiveFS bug in xattr retrieval, #1992
+- When running out of buffer memory when reading xattrs, only skip the
+  current file, #1993
+- Fixed "borg upgrade --tam" crashing with unencrypted repositories. Since
+  :ref:`the issue <tam_vuln>` is not relevant for unencrypted repositories,
+  it now does nothing and prints an error, #1981.
+- Fixed change-passphrase crashing with unencrypted repositories, #1978
+- Fixed "borg check repo::archive" indicating success if "archive" does not exist, #1997
+- borg check: print non-exit-code warning if --last or --prefix aren't fulfilled
+- fix bad parsing of wrong repo location syntax
+- create: don't create hard link refs to failed files,
+  mount: handle invalid hard link refs, #2092
+- detect mingw byte order, #2073
+- creating a new segment: use "xb" mode, #2099
+- mount: umount on SIGINT/^C when in foreground, #2082
+
+Other changes:
+
+- binary: use fixed AND freshly compiled pyinstaller bootloader, #2002
+- xattr: ignore empty names returned by llistxattr(2) et al
+- Enable the fault handler: install handlers for the SIGSEGV, SIGFPE, SIGABRT,
+  SIGBUS and SIGILL signals to dump the Python traceback.
+- Also print a traceback on SIGUSR2.
+- borg change-passphrase: print key location (simplify making a backup of it)
+- officially support Python 3.6 (setup.py: add Python 3.6 qualifier)
+- tests:
+
+  - vagrant / travis / tox: add Python 3.6 based testing
+  - vagrant: fix openbsd repo, #2042
+  - vagrant: fix the freebsd64 machine, #2037 #2067
+  - vagrant: use python 3.5.3 to build binaries, #2078
+  - vagrant: use osxfuse 3.5.4 for tests / to build binaries
+    vagrant: improve darwin64 VM settings
+  - travis: fix osxfuse install (fixes OS X testing on Travis CI)
+  - travis: require succeeding OS X tests, #2028
+  - travis: use latest pythons for OS X based testing
+  - use pytest-xdist to parallelize testing
+  - fix xattr test race condition, #2047
+  - setup.cfg: fix pytest deprecation warning, #2050
+- docs:
+
+  - language clarification - VM backup FAQ
+  - borg create: document how to backup stdin, #2013
+  - borg upgrade: fix incorrect title levels
+  - add CVE numbers for issues fixed in 1.0.9, #2106
+- fix typos (taken from Debian package patch)
+- remote: include data hexdump in "unexpected RPC data" error message
+- remote: log SSH command line at debug level
+- API_VERSION: use numberspaces, #2023
+- remove .github from pypi package, #2051
+- add pip and setuptools to requirements file, #2030
+- SyncFile: fix use of fd object after close (cosmetic)
+- Manifest.in: simplify, exclude \*.{so,dll,orig}, #2066
+- ignore posix_fadvise errors in repository.py, #2095
+  (works around issues with docker on ARM)
+- make LoggedIO.close_segment reentrant, avoid reentrance
+
+
+Version 1.0.9 (2016-12-20)
+--------------------------
+
+Security fixes:
+
+- A flaw in the cryptographic authentication scheme in Borg allowed an attacker
+  to spoof the manifest. See :ref:`tam_vuln` above for the steps you should
+  take.
+
+  CVE-2016-10099 was assigned to this vulnerability.
+- borg check: When rebuilding the manifest (which should only be needed very rarely)
+  duplicate archive names would be handled on a "first come first serve" basis, allowing
+  an attacker to apparently replace archives.
+
+  CVE-2016-10100 was assigned to this vulnerability.
+
+Bug fixes:
+
+- borg check:
+
+  - rebuild manifest if it's corrupted
+  - skip corrupted chunks during manifest rebuild
+- fix TypeError in integrity error handler, #1903, #1894
+- fix location parser for archives with @ char (regression introduced in 1.0.8), #1930
+- fix wrong duration/timestamps if system clock jumped during a create
+- fix progress display not updating if system clock jumps backwards
+- fix checkpoint interval being incorrect if system clock jumps
+
+Other changes:
+
+- docs:
+
+  - add python3-devel as a dependency for cygwin-based installation
+  - clarify extract is relative to current directory
+  - FAQ: fix link to changelog
+  - markup fixes
+- tests:
+
+  - test_get\_(cache|keys)_dir: clean env state, #1897
+  - get back pytest's pretty assertion failures, #1938
+- setup.py build_usage:
+
+  - fixed build_usage not processing all commands
+  - fixed build_usage not generating includes for debug commands
+
+
+Version 1.0.9rc1 (2016-11-27)
+-----------------------------
+
+Bug fixes:
+
+- files cache: fix determination of newest mtime in backup set (which is
+  used in cache cleanup and led to wrong "A" [added] status for unchanged
+  files in next backup), #1860.
+
+- borg check:
+
+  - fix incorrectly reporting attic 0.13 and earlier archives as corrupt
+  - handle repo w/o objects gracefully and also bail out early if repo is
+    *completely* empty, #1815.
+- fix tox/pybuild in 1.0-maint
+- at xattr module import time, loggers are not initialized yet
+
+New features:
+
+- borg umount <mountpoint>
+  exposed already existing umount code via the CLI api, so users can use it,
+  which is more consistent than using borg to mount and fusermount -u (or
+  umount) to un-mount, #1855.
+- implement borg create --noatime --noctime, fixes #1853
+
+Other changes:
+
+- docs:
+
+  - display README correctly on PyPI
+  - improve cache / index docs, esp. files cache docs, fixes #1825
+  - different pattern matching for --exclude, #1779
+  - datetime formatting examples for {now} placeholder, #1822
+  - clarify passphrase mode attic repo upgrade, #1854
+  - clarify --umask usage, #1859
+  - clarify how to choose PR target branch
+  - clarify prune behavior for different archive contents, #1824
+  - fix PDF issues, add logo, fix authors, headings, TOC
+  - move security verification to support section
+  - fix links in standalone README (:ref: tags)
+  - add link to security contact in README
+  - add FAQ about security
+  - move fork differences to FAQ
+  - add more details about resource usage
+- tests: skip remote tests on cygwin, #1268
+- travis:
+
+  - allow OS X failures until the brew cask osxfuse issue is fixed
+  - caskroom osxfuse-beta gone, it's osxfuse now (3.5.3)
+- vagrant:
+
+  - upgrade OSXfuse / FUSE for macOS to 3.5.3
+  - remove llfuse from tox.ini at a central place
+  - do not try to install llfuse on centos6
+  - fix FUSE test for darwin, #1546
+  - add windows virtual machine with cygwin
+  - Vagrantfile cleanup / code deduplication
+
+
+Version 1.0.8 (2016-10-29)
+--------------------------
+
+Bug fixes:
+
+- RemoteRepository: Fix busy wait in call_many, #940
+
+New features:
+
+- implement borgmajor/borgminor/borgpatch placeholders, #1694
+  {borgversion} was already there (full version string). With the new
+  placeholders you can now also get e.g. 1 or 1.0 or 1.0.8.
+
+Other changes:
+
+- avoid previous_location mismatch, #1741
+
+  due to the changed canonicalization for relative paths in PR #1711 / #1655
+  (implement /./ relpath hack), there would be a changed repo location warning
+  and the user would be asked if this is ok. this would break automation and
+  require manual intervention, which is unwanted.
+
+  thus, we automatically fix the previous_location config entry, if it only
+  changed in the expected way, but still means the same location.
+
+- docs:
+
+  - deployment.rst: do not use bare variables in ansible snippet
+  - add clarification about append-only mode, #1689
+  - setup.py: add comment about requiring llfuse, #1726
+  - update usage.rst / api.rst
+  - repo url / archive location docs + typo fix
+  - quickstart: add a comment about other (remote) filesystems
+
+- vagrant / tests:
+
+  - no chown when rsyncing (fixes boxes w/o vagrant group)
+  - fix FUSE permission issues on linux/freebsd, #1544
+  - skip FUSE test for borg binary + fakeroot
+  - ignore security.selinux xattrs, fixes tests on centos, #1735
+
+
+Version 1.0.8rc1 (2016-10-17)
+-----------------------------
+
+Bug fixes:
+
+- fix signal handling (SIGINT, SIGTERM, SIGHUP), #1620 #1593
+  Fixes e.g. leftover lock files for quickly repeated signals (e.g. Ctrl-C
+  Ctrl-C) or lost connections or systemd sending SIGHUP.
+- progress display: adapt formatting to narrow screens, do not crash, #1628
+- borg create --read-special - fix crash on broken symlink, #1584.
+  also correctly processes broken symlinks. before this regressed to a crash
+  (5b45385) a broken symlink would've been skipped.
+- process_symlink: fix missing backup_io()
+  Fixes a chmod/chown/chgrp/unlink/rename/... crash race between getting
+  dirents and dispatching to process_symlink.
+- yes(): abort on wrong answers, saying so, #1622
+- fixed exception borg serve raised when connection was closed before repository
+  was opened. Add an error message for this.
+- fix read-from-closed-FD issue, #1551
+  (this seems not to get triggered in 1.0.x, but was discovered in master)
+- hashindex: fix iterators (always raise StopIteration when exhausted)
+  (this seems not to get triggered in 1.0.x, but was discovered in master)
+- enable relative paths in ssh:// repo URLs, via /./relpath hack, #1655
+- allow repo paths with colons, #1705
+- update changed repo location immediately after acceptance, #1524
+- fix debug get-obj / delete-obj crash if object not found and remote repo,
+  #1684
+- pyinstaller: use a spec file to build borg.exe binary, exclude osxfuse dylib
+  on Mac OS X (avoids mismatch lib <-> driver), #1619
+
+New features:
+
+- add "borg key export" / "borg key import" commands, #1555, so users are able
+  to backup / restore their encryption keys more easily.
+
+  Supported formats are the keyfile format used by borg internally and a
+  special "paper" format with by line checksums for printed backups. For the
+  paper format, the import is an interactive process which checks each line as
+  soon as it is input.
+- add "borg debug-refcount-obj" to determine a repo objects' referrer counts,
+  #1352
+
+Other changes:
+
+- add "borg debug ..." subcommands
+  (borg debug-* still works, but will be removed in borg 1.1)
+- setup.py: Add subcommand support to build_usage.
+- remote: change exception message for unexpected RPC data format to indicate
+  dataflow direction.
+- improved messages / error reporting:
+
+  - IntegrityError: add placeholder for message, so that the message we give
+    appears not only in the traceback, but also in the (short) error message,
+    #1572
+  - borg.key: include chunk id in exception msgs, #1571
+  - better messages for cache newer than repo, #1700
+- vagrant (testing/build VMs):
+
+  - upgrade OSXfuse / FUSE for macOS to 3.5.2
+  - update Debian Wheezy boxes, #1686
+  - openbsd / netbsd: use own boxes, fixes misc rsync installation and
+    FUSE/llfuse related testing issues, #1695 #1696 #1670 #1671 #1728
+- docs:
+
+  - add docs for "key export" and "key import" commands, #1641
+  - fix inconsistency in FAQ (pv-wrapper).
+  - fix second block in "Easy to use" section not showing on GitHub, #1576
+  - add bestpractices badge
+  - link reference docs and faq about BORG_FILES_CACHE_TTL, #1561
+  - improve borg info --help, explain size infos, #1532
+  - add release signing key / security contact to README, #1560
+  - add contribution guidelines for developers
+  - development.rst: add sphinx_rtd_theme to the sphinx install command
+  - adjust border color in borg.css
+  - add debug-info usage help file
+  - internals.rst: fix typos
+  - setup.py: fix build_usage to always process all commands
+  - added docs explaining multiple --restrict-to-path flags, #1602
+  - add more specific warning about write-access debug commands, #1587
+  - clarify FAQ regarding backup of virtual machines, #1672
+- tests:
+
+  - work around FUSE xattr test issue with recent fakeroot
+  - simplify repo/hashindex tests
+  - travis: test FUSE-enabled borg, use trusty to have a recent FUSE
+  - re-enable FUSE tests for RemoteArchiver (no deadlocks any more)
+  - clean env for pytest based tests, #1714
+  - fuse_mount contextmanager: accept any options
+
+
+Version 1.0.7 (2016-08-19)
+--------------------------
+
+Security fixes:
+
+- borg serve: fix security issue with remote repository access, #1428
+  If you used e.g. --restrict-to-path /path/client1/ (with or without trailing
+  slash does not make a difference), it acted like a path prefix match using
+  /path/client1 (note the missing trailing slash) - the code then also allowed
+  working in e.g. /path/client13 or /path/client1000.
+
+  As this could accidentally lead to major security/privacy issues depending on
+  the paths you use, the behaviour was changed to be a strict directory match.
+  That means --restrict-to-path /path/client1 (with or without trailing slash
+  does not make a difference) now uses /path/client1/ internally (note the
+  trailing slash here!) for matching and allows precisely that path AND any
+  path below it. So, /path/client1 is allowed, /path/client1/repo1 is allowed,
+  but not /path/client13 or /path/client1000.
+
+  If you willingly used the undocumented (dangerous) previous behaviour, you
+  may need to rearrange your --restrict-to-path paths now. We are sorry if
+  that causes work for you, but we did not want a potentially dangerous
+  behaviour in the software (not even using a for-backwards-compat option).
+
+Bug fixes:
+
+- fixed repeated LockTimeout exceptions when borg serve tried to write into
+  a already write-locked repo (e.g. by a borg mount), #502 part b)
+  This was solved by the fix for #1220 in 1.0.7rc1 already.
+- fix cosmetics + file leftover for "not a valid borg repository", #1490
+- Cache: release lock if cache is invalid, #1501
+- borg extract --strip-components: fix leak of preloaded chunk contents
+- Repository, when a InvalidRepository exception happens:
+
+  - fix spurious, empty lock.roster
+  - fix repo not closed cleanly
+
+New features:
+
+- implement borg debug-info, fixes #1122
+  (just calls already existing code via cli, same output as below tracebacks)
+
+Other changes:
+
+- skip the O_NOATIME test on GNU Hurd, fixes #1315
+  (this is a very minor issue and the GNU Hurd project knows the bug)
+- document using a clean repo to test / build the release
+
+
+Version 1.0.7rc2 (2016-08-13)
+-----------------------------
+
+Bug fixes:
+
+- do not write objects to repository that are bigger than the allowed size,
+  borg will reject reading them, #1451.
+
+  Important: if you created archives with many millions of files or
+  directories, please verify if you can open them successfully,
+  e.g. try a "borg list REPO::ARCHIVE".
+- lz4 compression: dynamically enlarge the (de)compression buffer, the static
+  buffer was not big enough for archives with extremely many items, #1453
+- larger item metadata stream chunks, raise archive item limit by 8x, #1452
+- fix untracked segments made by moved DELETEs, #1442
+
+  Impact: Previously (metadata) segments could become untracked when deleting data,
+  these would never be cleaned up.
+- extended attributes (xattrs) related fixes:
+
+  - fixed a race condition in xattrs querying that led to the entire file not
+    being backed up (while logging the error, exit code = 1), #1469
+  - fixed a race condition in xattrs querying that led to a crash, #1462
+  - raise OSError including the error message derived from errno, deal with
+    path being a integer FD
+
+Other changes:
+
+- print active env var override by default, #1467
+- xattr module: refactor code, deduplicate, clean up
+- repository: split object size check into too small and too big
+- add a transaction_id assertion, so borg init on a broken (inconsistent)
+  filesystem does not look like a coding error in borg, but points to the
+  real problem.
+- explain confusing TypeError caused by compat support for old servers, #1456
+- add forgotten usage help file from build_usage
+- refactor/unify buffer code into helpers.Buffer class, add tests
+- docs:
+
+  - document archive limitation, #1452
+  - improve prune examples
+
+
+Version 1.0.7rc1 (2016-08-05)
+-----------------------------
+
+Bug fixes:
+
+- fix repo lock deadlocks (related to lock upgrade), #1220
+- catch unpacker exceptions, resync, #1351
+- fix borg break-lock ignoring BORG_REPO env var, #1324
+- files cache performance fixes (fixes unnecessary re-reading/chunking/
+  hashing of unmodified files for some use cases):
+
+  - fix unintended file cache eviction, #1430
+  - implement BORG_FILES_CACHE_TTL, update FAQ, raise default TTL from 10
+    to 20, #1338
+- FUSE:
+
+  - cache partially read data chunks (performance), #965, #966
+  - always create a root dir, #1125
+- use an OrderedDict for helptext, making the build reproducible, #1346
+- RemoteRepository init: always call close on exceptions, #1370 (cosmetic)
+- ignore stdout/stderr broken pipe errors (cosmetic), #1116
+
+New features:
+
+- better borg versions management support (useful esp. for borg servers
+  wanting to offer multiple borg versions and for clients wanting to choose
+  a specific server borg version), #1392:
+
+  - add BORG_VERSION environment variable before executing "borg serve" via ssh
+  - add new placeholder {borgversion}
+  - substitute placeholders in --remote-path
+
+- borg init --append-only option (makes using the more secure append-only mode
+  more convenient. when used remotely, this requires 1.0.7+ also on the borg
+  server), #1291.
+
+Other changes:
+
+- Vagrantfile:
+
+  - darwin64: upgrade to FUSE for macOS 3.4.1 (aka osxfuse), #1378
+  - xenial64: use user "ubuntu", not "vagrant" (as usual), #1331
+- tests:
+
+  - fix FUSE tests on OS X, #1433
+- docs:
+
+  - FAQ: add backup using stable filesystem names recommendation
+  - FAQ about glibc compatibility added, #491, glibc-check improved
+  - FAQ: 'A' unchanged file; remove ambiguous entry age sentence.
+  - OS X: install pkg-config to build with FUSE support, fixes #1400
+  - add notes about shell/sudo pitfalls with env. vars, #1380
+  - added platform feature matrix
+- implement borg debug-dump-repo-objs
+
+
+Version 1.0.6 (2016-07-12)
+--------------------------
+
+Bug fixes:
+
+- Linux: handle multiple LD_PRELOAD entries correctly, #1314, #1111
+- Fix crash with unclear message if the libc is not found, #1314, #1111
+
+Other changes:
+
+- tests:
+
+  - Fixed O_NOATIME tests for Solaris and GNU Hurd, #1315
+  - Fixed sparse file tests for (file) systems not supporting it, #1310
+- docs:
+
+  - Fixed syntax highlighting, #1313
+  - misc docs: added data processing overview picture
+
+
+Version 1.0.6rc1 (2016-07-10)
+-----------------------------
+
+New features:
+
+- borg check --repair: heal damaged files if missing chunks re-appear (e.g. if
+  the previously missing chunk was added again in a later backup archive),
+  #148. (*) Also improved logging.
+
+Bug fixes:
+
+- sync_dir: silence fsync() failing with EINVAL, #1287
+  Some network filesystems (like smbfs) don't support this and we use this in
+  repository code.
+- borg mount (FUSE):
+
+  - fix directories being shadowed when contained paths were also specified,
+    #1295
+  - raise I/O Error (EIO) on damaged files (unless -o allow_damaged_files is
+    used), #1302. (*)
+- borg extract: warn if a damaged file is extracted, #1299. (*)
+- Added some missing return code checks (ChunkIndex._add, hashindex_resize).
+- borg check: fix/optimize initial hash table size, avoids resize of the table.
+
+Other changes:
+
+- tests:
+
+  - add more FUSE tests, #1284
+  - deduplicate FUSE (u)mount code
+  - fix borg binary test issues, #862
+- docs:
+
+  - changelog: added release dates to older borg releases
+  - fix some sphinx (docs generator) warnings, #881
+
+Notes:
+
+(*) Some features depend on information (chunks_healthy list) added to item
+metadata when a file with missing chunks was "repaired" using all-zero
+replacement chunks. The chunks_healthy list is generated since borg 1.0.4,
+thus borg can't recognize such "repaired" (but content-damaged) files if the
+repair was done with an older borg version.
+
+
+Version 1.0.5 (2016-07-07)
+--------------------------
+
+Bug fixes:
+
+- borg mount: fix FUSE crash in xattr code on Linux introduced in 1.0.4, #1282
+
+Other changes:
+
+- backport some FAQ entries from master branch
+- add release helper scripts
+- Vagrantfile:
+
+  - centos6: no FUSE, don't build binary
+  - add xz for redhat-like dists
+
+
+Version 1.0.4 (2016-07-07)
+--------------------------
+
+New features:
+
+- borg serve --append-only, #1168
+  This was included because it was a simple change (append-only functionality
+  was already present via repository config file) and makes better security now
+  practically usable.
+- BORG_REMOTE_PATH environment variable, #1258
+  This was included because it was a simple change (--remote-path cli option
+  was already present) and makes borg much easier to use if you need it.
+- Repository: cleanup incomplete transaction on "no space left" condition.
+  In many cases, this can avoid a 100% full repo filesystem (which is very
+  problematic as borg always needs free space - even to delete archives).
+
+Bug fixes:
+
+- Fix wrong handling and reporting of OSErrors in borg create, #1138.
+  This was a serious issue: in the context of "borg create", errors like
+  repository I/O errors (e.g. disk I/O errors, ssh repo connection errors)
+  were handled badly and did not lead to a crash (which would be good for this
+  case, because the repo transaction would be incomplete and trigger a
+  transaction rollback to clean up).
+  Now, error handling for source files is cleanly separated from every other
+  error handling, so only problematic input files are logged and skipped.
+- Implement fail-safe error handling for borg extract.
+  Note that this isn't nearly as critical as the borg create error handling
+  bug, since nothing is written to the repo. So this was "merely" misleading
+  error reporting.
+- Add missing error handler in directory attr restore loop.
+- repo: make sure write data hits disk before the commit tag (#1236) and also
+  sync the containing directory.
+- FUSE: getxattr fail must use errno.ENOATTR, #1126
+  (fixes Mac OS X Finder malfunction: "zero bytes" file length, access denied)
+- borg check --repair: do not lose information about the good/original chunks.
+  If we do not lose the original chunk IDs list when "repairing" a file
+  (replacing missing chunks with all-zero chunks), we have a chance to "heal"
+  the file back into its original state later, in case the chunks re-appear
+  (e.g. in a fresh backup). Healing is not implemented yet, see #148.
+- fixes for --read-special mode:
+
+  - ignore known files cache, #1241
+  - fake regular file mode, #1214
+  - improve symlinks handling, #1215
+- remove passphrase from subprocess environment, #1105
+- Ignore empty index file (will trigger index rebuild), #1195
+- add missing placeholder support for --prefix, #1027
+- improve exception handling for placeholder replacement
+- catch and format exceptions in arg parsing
+- helpers: fix "undefined name 'e'" in exception handler
+- better error handling for missing repo manifest, #1043
+- borg delete:
+
+  - make it possible to delete a repo without manifest
+  - borg delete --forced allows one to delete corrupted archives, #1139
+- borg check:
+
+  - make borg check work for empty repo
+  - fix resync and msgpacked item qualifier, #1135
+  - rebuild_manifest: fix crash if 'name' or 'time' key were missing.
+  - better validation of item metadata dicts, #1130
+  - better validation of archive metadata dicts
+- close the repo on exit - even if rollback did not work, #1197.
+  This is rather cosmetic, it avoids repo closing in the destructor.
+
+- tests:
+
+  - fix sparse file test, #1170
+  - flake8: ignore new F405, #1185
+  - catch "invalid argument" on cygwin, #257
+  - fix sparseness assertion in test prep, #1264
+
+Other changes:
+
+- make borg build/work on OpenSSL 1.0 and 1.1, #1187
+- docs / help:
+
+  - fix / clarify prune help, #1143
+  - fix "patterns" help formatting
+  - add missing docs / help about placeholders
+  - resources: rename atticmatic to borgmatic
+  - document sshd settings, #545
+  - more details about checkpoints, add split trick, #1171
+  - support docs: add freenode web chat link, #1175
+  - add prune visualization / example, #723
+  - add note that Fnmatch is default, #1247
+  - make clear that lzma levels > 6 are a waste of cpu cycles
+  - add a "do not edit" note to auto-generated files, #1250
+  - update cygwin installation docs
+- repository interoperability with borg master (1.1dev) branch:
+
+  - borg check: read item metadata keys from manifest, #1147
+  - read v2 hints files, #1235
+  - fix hints file "unknown version" error handling bug
+- tests: add tests for format_line
+- llfuse: update version requirement for freebsd
+- Vagrantfile:
+
+  - use openbsd 5.9, #716
+  - do not install llfuse on netbsd (broken)
+  - update OSXfuse to version 3.3.3
+  - use Python 3.5.2 to build the binaries
+- glibc compatibility checker: scripts/glibc_check.py
+- add .eggs to .gitignore
+
+
+Version 1.0.3 (2016-05-20)
+--------------------------
+
+Bug fixes:
+
+- prune: avoid that checkpoints are kept and completed archives are deleted in
+  a prune run), #997
+- prune: fix commandline argument validation - some valid command lines were
+  considered invalid (annoying, but harmless), #942
+- fix capabilities extraction on Linux (set xattrs last, after chown()), #1069
+- repository: fix commit tags being seen in data
+- when probing key files, do binary reads. avoids crash when non-borg binary
+  files are located in borg's key files directory.
+- handle SIGTERM and make a clean exit - avoids orphan lock files.
+- repository cache: don't cache large objects (avoid using lots of temp. disk
+  space), #1063
+
+Other changes:
+
+- Vagrantfile: OS X: update osxfuse / install lzma package, #933
+- setup.py: add check for platform_darwin.c
+- setup.py: on freebsd, use a llfuse release that builds ok
+- docs / help:
+
+  - update readthedocs URLs, #991
+  - add missing docs for "borg break-lock", #992
+  - borg create help: add some words to about the archive name
+  - borg create help: document format tags, #894
+
+
+Version 1.0.2 (2016-04-16)
+--------------------------
+
+Bug fixes:
+
+- fix malfunction and potential corruption on (nowadays rather rare) big-endian
+  architectures or bi-endian archs in (rare) BE mode. #886, #889
+
+  cache resync / index merge was malfunctioning due to this, potentially
+  leading to data loss. borg info had cosmetic issues (displayed wrong values).
+
+  note: all (widespread) little-endian archs (like x86/x64) or bi-endian archs
+  in (widespread) LE mode (like ARMEL, MIPSEL, ...) were NOT affected.
+- add overflow and range checks for 1st (special) uint32 of the hashindex
+  values, switch from int32 to uint32.
+- fix so that refcount will never overflow, but just stick to max. value after
+  a overflow would have occurred.
+- borg delete: fix --cache-only for broken caches, #874
+
+  Makes --cache-only idempotent: it won't fail if the cache is already deleted.
+- fixed borg create --one-file-system erroneously traversing into other
+  filesystems (if starting fs device number was 0), #873
+- workaround a bug in Linux fadvise FADV_DONTNEED, #907
+
+Other changes:
+
+- better test coverage for hashindex, incl. overflow testing, checking correct
+  computations so endianness issues would be discovered.
+- reproducible doc for ProgressIndicator*,  make the build reproducible.
+- use latest llfuse for vagrant machines
+- docs:
+
+  - use /path/to/repo in examples, fixes #901
+  - fix confusing usage of "repo" as archive name (use "arch")
+
+
+Version 1.0.1 (2016-04-08)
+--------------------------
+
+New features:
+
+Usually there are no new features in a bugfix release, but these were added
+due to their high impact on security/safety/speed or because they are fixes
+also:
+
+- append-only mode for repositories, #809, #36 (see docs)
+- borg create: add --ignore-inode option to make borg detect unmodified files
+  even if your filesystem does not have stable inode numbers (like sshfs and
+  possibly CIFS).
+- add options --warning, --error, --critical for missing log levels, #826.
+  it's not recommended to suppress warnings or errors, but the user may decide
+  this on his own.
+  note: --warning is not given to borg serve so a <= 1.0.0 borg will still
+  work as server (it is not needed as it is the default).
+  do not use --error or --critical when using a <= 1.0.0 borg server.
+
+Bug fixes:
+
+- fix silently skipping EIO, #748
+- add context manager for Repository (avoid orphan repository locks), #285
+- do not sleep for >60s while waiting for lock, #773
+- unpack file stats before passing to FUSE
+- fix build on illumos
+- don't try to backup doors or event ports (Solaris and derivatives)
+- remove useless/misleading libc version display, #738
+- test suite: reset exit code of persistent archiver, #844
+- RemoteRepository: clean up pipe if remote open() fails
+- Remote: don't print tracebacks for Error exceptions handled downstream, #792
+- if BORG_PASSPHRASE is present but wrong, don't prompt for password, but fail
+  instead, #791
+- ArchiveChecker: move "orphaned objects check skipped" to INFO log level, #826
+- fix capitalization, add ellipses, change log level to debug for 2 messages,
+  #798
+
+Other changes:
+
+- update llfuse requirement, llfuse 1.0 works
+- update OS / dist packages on build machines, #717
+- prefer showing --info over -v in usage help, #859
+- docs:
+
+  - fix cygwin requirements (gcc-g++)
+  - document how to debug / file filesystem issues, #664
+  - fix reproducible build of api docs
+  - RTD theme: CSS !important overwrite, #727
+  - Document logo font. Recreate logo png. Remove GIMP logo file.
+
+
+Version 1.0.0 (2016-03-05)
+--------------------------
+
+The major release number change (0.x -> 1.x) indicates bigger incompatible
+changes, please read the compatibility notes, adapt / test your scripts and
+check your backup logs.
+
+Compatibility notes:
+
+- drop support for python 3.2 and 3.3, require 3.4 or 3.5, #221 #65 #490
+  note: we provide binaries that include python 3.5.1 and everything else
+  needed. they are an option in case you are stuck with < 3.4 otherwise.
+- change encryption to be on by default (using "repokey" mode)
+- moved keyfile keys from ~/.borg/keys to ~/.config/borg/keys,
+  you can either move them manually or run "borg upgrade <REPO>"
+- remove support for --encryption=passphrase,
+  use borg migrate-to-repokey to switch to repokey mode, #97
+- remove deprecated --compression <number>,
+  use --compression zlib,<number> instead
+  in case of 0, you could also use --compression none
+- remove deprecated --hourly/daily/weekly/monthly/yearly
+  use --keep-hourly/daily/weekly/monthly/yearly instead
+- remove deprecated --do-not-cross-mountpoints,
+  use --one-file-system instead
+- disambiguate -p option, #563:
+
+  - -p now is same as --progress
+  - -P now is same as --prefix
+- remove deprecated "borg verify",
+  use "borg extract --dry-run" instead
+- cleanup environment variable semantics, #355
+  the environment variables used to be "yes sayers" when set, this was
+  conceptually generalized to "automatic answerers" and they just give their
+  value as answer (as if you typed in that value when being asked).
+  See the "usage" / "Environment Variables" section of the docs for details.
+- change the builtin default for --chunker-params, create 2MiB chunks, #343
+  --chunker-params new default: 19,23,21,4095 - old default: 10,23,16,4095
+
+  one of the biggest issues with borg < 1.0 (and also attic) was that it had a
+  default target chunk size of 64kiB, thus it created a lot of chunks and thus
+  also a huge chunk management overhead (high RAM and disk usage).
+
+  please note that the new default won't change the chunks that you already
+  have in your repository. the new big chunks do not deduplicate with the old
+  small chunks, so expect your repo to grow at least by the size of every
+  changed file and in the worst case (e.g. if your files cache was lost / is
+  not used) by the size of every file (minus any compression you might use).
+
+  in case you want to immediately see a much lower resource usage (RAM / disk)
+  for chunks management, it might be better to start with a new repo than
+  continuing in the existing repo (with an existing repo, you'ld have to wait
+  until all archives with small chunks got pruned to see a lower resource
+  usage).
+
+  if you used the old --chunker-params default value (or if you did not use
+  --chunker-params option at all) and you'ld like to continue using small
+  chunks (and you accept the huge resource usage that comes with that), just
+  explicitly use borg create --chunker-params=10,23,16,4095.
+- archive timestamps: the 'time' timestamp now refers to archive creation
+  start time (was: end time), the new 'time_end' timestamp refers to archive
+  creation end time. This might affect prune if your backups take rather long.
+  if you give a timestamp via cli this is stored into 'time', therefore it now
+  needs to mean archive creation start time.
+
+New features:
+
+- implement password roundtrip, #695
+
+Bug fixes:
+
+- remote end does not need cache nor keys directories, do not create them, #701
+- added retry counter for passwords, #703
+
+Other changes:
+
+- fix compiler warnings, #697
+- docs:
+
+  - update README.rst to new changelog location in docs/changes.rst
+  - add Teemu to AUTHORS
+  - changes.rst: fix old chunker params, #698
+  - FAQ: how to limit bandwidth
+
+
+Version 1.0.0rc2 (2016-02-28)
+-----------------------------
+
+New features:
+
+- format options for location: user, pid, fqdn, hostname, now, utcnow, user
+- borg list --list-format
+- borg prune -v --list enables the keep/prune list output, #658
+
+Bug fixes:
+
+- fix _open_rb noatime handling, #657
+- add a simple archivename validator, #680
+- borg create --stats: show timestamps in localtime, use same labels/formatting
+  as borg info, #651
+- llfuse compatibility fixes (now compatible with: 0.40, 0.41, 0.42)
+
+Other changes:
+
+- it is now possible to use "pip install borgbackup[fuse]" to automatically
+  install the llfuse dependency using the correct version requirement
+  for it. you still need to care about having installed the FUSE / build
+  related OS package first, though, so that building llfuse can succeed.
+- Vagrant: drop Ubuntu Precise (12.04) - does not have Python >= 3.4
+- Vagrant: use pyinstaller v3.1.1 to build binaries
+- docs:
+
+  - borg upgrade: add to docs that only LOCAL repos are supported
+  - borg upgrade also handles borg 0.xx -> 1.0
+  - use pip extras or requirements file to install llfuse
+  - fix order in release process
+  - updated usage docs and other minor / cosmetic fixes
+  - verified borg examples in docs, #644
+  - freebsd dependency installation and FUSE configuration, #649
+  - add example how to restore a raw device, #671
+  - add a hint about the dev headers needed when installing from source
+  - add examples for delete (and handle delete after list, before prune), #656
+  - update example for borg create -v --stats (use iso datetime format), #663
+  - added example to BORG_RSH docs
+  - "connection closed by remote": add FAQ entry and point to issue #636
+
+
+Version 1.0.0rc1 (2016-02-07)
+-----------------------------
+
+New features:
+
+- borg migrate-to-repokey ("passphrase" -> "repokey" encryption key mode)
+- implement --short for borg list REPO, #611
+- implement --list for borg extract (consistency with borg create)
+- borg serve: overwrite client's --restrict-to-path with ssh forced command's
+  option value (but keep everything else from the client commandline), #544
+- use $XDG_CONFIG_HOME/keys for keyfile keys (~/.config/borg/keys), #515
+- "borg upgrade" moves the keyfile keys to the new location
+- display both archive creation start and end time in "borg info", #627
+
+
+Bug fixes:
+
+- normalize trailing slashes for the repository path, #606
+- Cache: fix exception handling in __init__, release lock, #610
+
+Other changes:
+
+- suppress unneeded exception context (PEP 409), simpler tracebacks
+- removed special code needed to deal with imperfections / incompatibilities /
+  missing stuff in py 3.2/3.3, simplify code that can be done simpler in 3.4
+- removed some version requirements that were kept on old versions because
+  newer did not support py 3.2 any more
+- use some py 3.4+ stdlib code instead of own/openssl/pypi code:
+
+  - use os.urandom instead of own cython openssl RAND_bytes wrapper, #493
+  - use hashlib.pbkdf2_hmac from py stdlib instead of own openssl wrapper
+  - use hmac.compare_digest instead of == operator (constant time comparison)
+  - use stat.filemode instead of homegrown code
+  - use "mock" library from stdlib, #145
+  - remove borg.support (with non-broken argparse copy), it is ok in 3.4+, #358
+- Vagrant: copy CHANGES.rst as symlink, #592
+- cosmetic code cleanups, add flake8 to tox/travis, #4
+- docs / help:
+
+  - make "borg -h" output prettier, #591
+  - slightly rephrase prune help
+  - add missing example for --list option of borg create
+  - quote exclude line that includes an asterisk to prevent shell expansion
+  - fix dead link to license
+  - delete Ubuntu Vivid, it is not supported anymore (EOL)
+  - OS X binary does not work for older OS X releases, #629
+  - borg serve's special support for forced/original ssh commands, #544
+  - misc. updates and fixes
diff --git a/docs/index.rst b/docs/index.rst
index 9675ed989..6fc3bb6a5 100644
--- a/docs/index.rst
+++ b/docs/index.rst
@@ -18,6 +18,8 @@ Borg Documentation
    faq
    support
    changes
+   changes_1.x
+   changes_0.x
    internals
    development
    authors

From 51cf85e627233feaae689b53950372dd8298b743 Mon Sep 17 00:00:00 2001
From: Thomas Waldmann <tw@waldmann-edv.de>
Date: Fri, 24 Jun 2022 01:19:19 +0200
Subject: [PATCH 071/160] build_usage / build_man / doc updates

---
 docs/faq.rst                                  | 247 ++---------------
 docs/installation.rst                         |   4 +-
 docs/internals/data-structures.rst            |   7 +-
 docs/internals/frontends.rst                  |   4 +-
 docs/internals/security.rst                   | 117 +-------
 docs/man/borg-benchmark-cpu.1                 |  14 +-
 docs/man/borg-benchmark-crud.1                |  11 +-
 docs/man/borg-benchmark.1                     |   6 +-
 docs/man/borg-break-lock.1                    |  14 +-
 docs/man/borg-check.1                         |  27 +-
 docs/man/borg-common.1                        |  35 +--
 docs/man/borg-compact.1                       |  21 +-
 docs/man/borg-compression.1                   |   6 +-
 docs/man/borg-config.1                        |  23 +-
 docs/man/borg-create.1                        | 110 ++++----
 docs/man/borg-delete.1                        |  63 ++---
 docs/man/borg-diff.1                          |  57 +---
 docs/man/borg-export-tar.1                    |  16 +-
 docs/man/borg-extract.1                       |  44 +--
 docs/man/borg-import-tar.1                    |  38 +--
 docs/man/borg-info.1                          |  82 ++----
 docs/man/borg-key-change-algorithm.1          |  10 +-
 docs/man/borg-key-change-location.1           |  27 +-
 docs/man/borg-key-change-passphrase.1         |  21 +-
 docs/man/borg-key-export.1                    |  14 +-
 docs/man/borg-key-import.1                    |  12 +-
 docs/man/borg-key.1                           |   6 +-
 docs/man/borg-list.1                          | 136 ++-------
 docs/man/borg-mount.1                         |  21 +-
 docs/man/borg-patterns.1                      | 258 ++++++++++--------
 docs/man/borg-placeholders.1                  |   8 +-
 docs/man/borg-prune.1                         |  48 ++--
 docs/man/{borg-init.1 => borg-rcreate.1}      |  86 +++---
 docs/man/borg-rdelete.1                       |  90 ++++++
 docs/man/borg-recreate.1                      |  57 ++--
 docs/man/borg-rename.1                        |  22 +-
 docs/man/borg-rinfo.1                         |  83 ++++++
 docs/man/borg-rlist.1                         | 160 +++++++++++
 docs/man/borg-serve.1                         |   8 +-
 docs/man/borg-transfer.1                      | 100 +++++++
 docs/man/borg-umount.1                        |  25 +-
 docs/man/borg-upgrade.1                       |  24 +-
 docs/man/borg-with-lock.1                     |  11 +-
 docs/man/borg.1                               | 117 ++++----
 docs/man/borgfs.1                             |  23 +-
 docs/man_intro.rst                            |   4 +-
 docs/quickstart.rst                           |  51 ++--
 docs/quickstart_example.rst.inc               |  53 ++--
 docs/usage.rst                                |  20 +-
 docs/usage/benchmark_cpu.rst.inc              |   1 +
 docs/usage/benchmark_crud.rst.inc             |  24 +-
 docs/usage/break-lock.rst.inc                 |  18 +-
 docs/usage/check.rst.inc                      |  11 +-
 docs/usage/common-options.rst.inc             |  35 +--
 docs/usage/compact.rst                        |   7 +-
 docs/usage/compact.rst.inc                    |   8 +-
 docs/usage/config.rst                         |   6 +-
 docs/usage/config.rst.inc                     |   6 +-
 docs/usage/create.rst                         |  48 ++--
 docs/usage/create.rst.inc                     |  12 +-
 docs/usage/delete.rst                         |  18 +-
 docs/usage/delete.rst.inc                     |  26 +-
 docs/usage/diff.rst                           |  33 +--
 docs/usage/diff.rst.inc                       |  12 +-
 docs/usage/export-tar.rst.inc                 |   8 +-
 docs/usage/extract.rst                        |  12 +-
 docs/usage/extract.rst.inc                    |   8 +-
 docs/usage/general.rst                        |   4 +-
 docs/usage/general/environment.rst.inc        |   7 +-
 .../general/positional-arguments.rst.inc      |   8 +-
 .../general/repository-locations.rst.inc      |  15 +-
 docs/usage/general/repository-urls.rst.inc    |  24 +-
 docs/usage/help.rst.inc                       | 233 ++++++++--------
 docs/usage/import-tar.rst.inc                 |   8 +-
 docs/usage/info.rst                           |  64 +----
 docs/usage/info.rst.inc                       |  10 +-
 docs/usage/init.rst                           |  22 --
 docs/usage/key.rst                            |  10 +-
 docs/usage/key_change-algorithm.rst.inc       |  24 +-
 docs/usage/key_change-location.rst.inc        |  16 +-
 docs/usage/key_change-passphrase.rst.inc      |  18 +-
 docs/usage/key_export.rst.inc                 |  36 ++-
 docs/usage/key_import.rst.inc                 |  32 +--
 docs/usage/list.rst                           |  17 +-
 docs/usage/list.rst.inc                       | 134 +++------
 docs/usage/mount.rst                          |  19 +-
 docs/usage/mount.rst.inc                      |   6 +-
 docs/usage/notes.rst                          |  16 +-
 docs/usage/prune.rst                          |  10 +-
 docs/usage/prune.rst.inc                      |   8 +-
 docs/usage/rcreate.rst                        |  25 ++
 docs/usage/{init.rst.inc => rcreate.rst.inc}  |  31 +--
 docs/usage/rdelete.rst                        |  13 +
 docs/usage/rdelete.rst.inc                    |  66 +++++
 docs/usage/recreate.rst                       |  19 +-
 docs/usage/recreate.rst.inc                   | 125 +++++----
 docs/usage/rename.rst                         |   8 +-
 docs/usage/rename.rst.inc                     |  30 +-
 docs/usage/rinfo.rst                          |  16 ++
 docs/usage/rinfo.rst.inc                      |  56 ++++
 docs/usage/rlist.rst                          |  13 +
 docs/usage/rlist.rst.inc                      | 125 +++++++++
 docs/usage/tar.rst                            |  18 +-
 docs/usage/transfer.rst                       |   1 +
 docs/usage/transfer.rst.inc                   |  87 ++++++
 docs/usage/upgrade.rst.inc                    |   8 +-
 docs/usage/with-lock.rst.inc                  |  28 +-
 src/borg/archiver.py                          |  73 ++---
 108 files changed, 2134 insertions(+), 2083 deletions(-)
 rename docs/man/{borg-init.1 => borg-rcreate.1} (81%)
 create mode 100644 docs/man/borg-rdelete.1
 create mode 100644 docs/man/borg-rinfo.1
 create mode 100644 docs/man/borg-rlist.1
 create mode 100644 docs/man/borg-transfer.1
 delete mode 100644 docs/usage/init.rst
 create mode 100644 docs/usage/rcreate.rst
 rename docs/usage/{init.rst.inc => rcreate.rst.inc} (91%)
 create mode 100644 docs/usage/rdelete.rst
 create mode 100644 docs/usage/rdelete.rst.inc
 create mode 100644 docs/usage/rinfo.rst
 create mode 100644 docs/usage/rinfo.rst.inc
 create mode 100644 docs/usage/rlist.rst
 create mode 100644 docs/usage/rlist.rst.inc
 create mode 100644 docs/usage/transfer.rst
 create mode 100644 docs/usage/transfer.rst.inc

diff --git a/docs/faq.rst b/docs/faq.rst
index b91c0ea59..9566fdec7 100644
--- a/docs/faq.rst
+++ b/docs/faq.rst
@@ -27,13 +27,7 @@ which is slower.
 Can I backup from multiple servers into a single repository?
 ------------------------------------------------------------
 
-Yes, this is *possible* from the technical standpoint, but it is
-*not recommended* from the security perspective. BorgBackup is
-built upon a defined :ref:`attack_model` that cannot provide its
-guarantees for multiple clients using the same repository. See
-:ref:`borg_security_critique` for a detailed explanation.
-
-Also, in order for the deduplication used by Borg to work, it
+In order for the deduplication used by Borg to work, it
 needs to keep a local cache containing checksums of all file
 chunks already stored in the repository. This cache is stored in
 ``~/.cache/borg/``.  If Borg detects that a repository has been
@@ -49,7 +43,7 @@ Can I back up to multiple, swapped backup targets?
 --------------------------------------------------
 
 It is possible to swap your backup disks if each backup medium is assigned its
-own repository by creating a new one with :ref:`borg_init`.
+own repository by creating a new one with :ref:`borg_rcreate`.
 
 Can I copy or synchronize my repo to another location?
 ------------------------------------------------------
@@ -57,8 +51,8 @@ Can I copy or synchronize my repo to another location?
 If you want to have redundant backup repositories (preferably at separate
 locations), the recommended way to do that is like this:
 
-- ``borg init repo1``
-- ``borg init repo2``
+- ``borg rcreate repo1``
+- ``borg rcreate repo2``
 - client machine ---borg create---> repo1
 - client machine ---borg create---> repo2
 
@@ -94,10 +88,6 @@ Also, you must not run borg against multiple instances of the same repo
   think they are identical and e.g. use the same local cache for them
   (which is an issue if they happen to be not the same).
   See :issue:`4272` for an example.
-- Encryption security issues if you would update repo and copy-of-repo
-  independently, due to AES counter reuse (when using legacy encryption modes).
-
-See also: :ref:`faq_corrupt_repo`
 
 "this is either an attack or unsafe" warning
 --------------------------------------------
@@ -118,9 +108,9 @@ you could delete the manifest-timestamp and the local cache:
 
 ::
 
-  borg config repo id   # shows the REPO_ID
+  borg config id   # shows the REPO_ID
   rm ~/.config/borg/security/REPO_ID/manifest-timestamp
-  borg delete --cache-only REPO
+  borg rdelete --cache-only
 
 This is an unsafe and unsupported way to use borg, you have been warned.
 
@@ -199,11 +189,6 @@ really desperate (e.g. if you have no completed backup of that file and you'ld
 rather get a partial file extracted than nothing). You do **not** want to give
 that option under any normal circumstances.
 
-Note that checkpoints inside files are created only since version 1.1, make
-sure you have an up-to-date version of borgbackup if you want to continue
-instead of retransferring a huge file. In some cases, there is only an outdated
-version shipped with your distribution (e.g. Debian). See :ref:`installation`.
-
 How can I backup huge file(s) over a unstable connection?
 ---------------------------------------------------------
 
@@ -241,33 +226,9 @@ then use ``tar`` to perform the comparison:
 
 ::
 
-    borg export-tar /path/to/repo::archive-name - | tar --compare -f - -C /path/to/compare/to
+    borg export-tar archive-name - | tar --compare -f - -C /path/to/compare/to
 
 
-.. _faq_corrupt_repo:
-
-My repository is corrupt, how can I restore from an older copy of it?
----------------------------------------------------------------------
-
-Note: this is only required for repos using legacy encryption modes.
-
-If your repositories are encrypted and have the same ID, the recommended method
-is to delete the corrupted repository, but keep its security info, and then copy
-the working repository to the same location:
-
-::
-
-    borg delete --keep-security-info /path/to/repo
-    rsync -aH /path/to/repo-working/ /path/to/repo  # Note the trailing slash.
-
-A plain delete command would remove the security info in
-``~/.config/borg/security``, including the nonce value. In BorgBackup
-:ref:`security_encryption` is AES-CTR, where the nonce is a counter. When the
-working repo was used later for creating new archives, Borg would re-use nonce
-values due to starting from a lower counter value given by the older copy of the
-repository. To prevent this, the ``keep-security-info`` option is applied so
-that the client-side nonce counter is kept.
-
 Can Borg add redundancy to the backup data to deal with hardware malfunction?
 -----------------------------------------------------------------------------
 
@@ -296,7 +257,7 @@ SMR (shingled magnetic recording) hard drives are very different from
 regular hard drives. Applications have to behave in certain ways or
 performance will be heavily degraded.
 
-Borg 1.1 ships with default settings suitable for SMR drives,
+Borg ships with default settings suitable for SMR drives,
 and has been successfully tested on *Seagate Archive v2* drives
 using the ext4 file system.
 
@@ -436,16 +397,16 @@ Say you want to prune ``/var/log`` faster than the rest of
 archive *names* and then implement different prune policies for
 different prefixes. For example, you could have a script that does::
 
-    borg create --exclude var/log $REPOSITORY:main-$(date +%Y-%m-%d) /
-    borg create $REPOSITORY:logs-$(date +%Y-%m-%d) /var/log
+    borg create --exclude var/log main-$(date +%Y-%m-%d) /
+    borg create logs-$(date +%Y-%m-%d) /var/log
 
 Then you would have two different prune calls with different policies::
 
-    borg prune --verbose --list -d 30 --prefix main- "$REPOSITORY"
-    borg prune --verbose --list -d 7  --prefix logs- "$REPOSITORY"
+    borg prune --verbose --list -d 30 --prefix main-
+    borg prune --verbose --list -d 7  --prefix logs-
 
-This will keep 7 days of logs and 30 days of everything else. Borg 1.1
-also supports the ``--glob-archives`` parameter.
+This will keep 7 days of logs and 30 days of everything else.
+Borg also supports the ``--glob-archives`` parameter.
 
 How do I remove files from an existing backup?
 ----------------------------------------------
@@ -476,37 +437,6 @@ to change them.
 Security
 ########
 
-.. _borg_security_critique:
-
-Isn't BorgBackup's legacy AES-CTR-based crypto broken?
-------------------------------------------------------
-
-Note: in borg 1.3 new AEAD cipher based modes with session keys were added,
-solving the issues of the legacy modes.
-
-If a nonce (counter) value is reused, AES-CTR mode crypto is broken.
-
-To exploit the AES counter management issue, an attacker would need to have
-access to the borg repository.
-
-By tampering with the repo, the attacker could bring the repo into a state so
-that it reports a lower "highest used counter value" than the one that actually
-was used. The client would usually notice that, because it rather trusts the
-clientside stored "highest used counter value" than trusting the server.
-
-But there are situations, where this is simply not possible:
-
-- If clients A and B used the repo, the client A can only know its own highest
-  CTR value, but not the one produced by B. That is only known to (B and) the
-  server (the repo) and thus the client A needs to trust the server about the
-  value produced by B in that situation. You can't do much about this except
-  not having multiple clients per repo.
-
-- Even if there is only one client, if client-side information is completely
-  lost (e.g. due to disk defect), the client also needs to trust the value from
-  server side. You can avoid this by not continuing to write to the repository
-  after you have lost clientside borg information.
-
 .. _home_config_borg:
 
 How important is the $HOME/.config/borg directory?
@@ -583,7 +513,7 @@ Using ``BORG_PASSCOMMAND`` with a properly permissioned file
 Using keyfile-based encryption with a blank passphrase
   It is possible to encrypt your repository in ``keyfile`` mode instead of the default
   ``repokey`` mode and use a blank passphrase for the key file (simply press Enter twice
-  when ``borg init`` asks for the password). See :ref:`encrypted_repos`
+  when ``borg rcreate`` asks for the password). See :ref:`encrypted_repos`
   for more details.
 
 Using ``BORG_PASSCOMMAND`` with macOS Keychain
@@ -717,34 +647,6 @@ Send a private email to the :ref:`security contact <security-contact>`
 if you think you have discovered a security issue.
 Please disclose security issues responsibly.
 
-How important are the nonce files?
-------------------------------------
-
-This only applies to repositories using legacy encryption modes.
-
-Borg uses :ref:`AES-CTR encryption <borg_security_critique>`. An
-essential part of AES-CTR is a sequential counter that must **never**
-repeat. If the same value of the counter is used twice in the same repository,
-an attacker can decrypt the data. The counter is stored in the home directory
-of each user ($HOME/.config/borg/security/$REPO_ID/nonce) as well as
-in the repository (/path/to/repo/nonce). When creating a new archive borg uses
-the highest of the two values. The value of the counter in the repository may be
-higher than your local value if another user has created an archive more recently
-than you did.
-
-Since the nonce is not necessary to read the data that is already encrypted,
-``borg info``, ``borg list``, ``borg extract`` and ``borg mount`` should work
-just fine without it.
-
-If the nonce file stored in the repo is lost, but you still have your local copy,
-borg will recreate the repository nonce file the next time you run ``borg create``.
-This should be safe for repositories that are only used from one user account
-on one machine.
-
-For repositories that are used by multiple users and/or from multiple machines
-it is safest to avoid running *any* commands that modify the repository after
-the nonce is deleted or if you suspect it may have been tampered with. See :ref:`attack_model`.
-
 Common issues
 #############
 
@@ -789,9 +691,9 @@ How can I deal with my very unstable SSH connection?
 If you have issues with lost connections during long-running borg commands, you
 could try to work around:
 
-- Make partial extracts like ``borg extract REPO PATTERN`` to do multiple
+- Make partial extracts like ``borg extract PATTERN`` to do multiple
   smaller extraction runs that complete before your connection has issues.
-- Try using ``borg mount REPO MOUNTPOINT`` and ``rsync -avH`` from
+- Try using ``borg mount MOUNTPOINT`` and ``rsync -avH`` from
   ``MOUNTPOINT`` to your desired extraction directory. If the connection breaks
   down, just repeat that over and over again until rsync does not find anything
   to do any more. Due to the way borg mount works, this might be less efficient
@@ -846,7 +748,7 @@ space for chunks.archive.d (see :issue:`235` for details):
 ::
 
     # this assumes you are working with the same user as the backup.
-    cd ~/.cache/borg/$(borg config /path/to/repo id)
+    cd ~/.cache/borg/$(borg config id)
     rm -rf chunks.archive.d ; touch chunks.archive.d
 
 This deletes all the cached archive chunk indexes and replaces the directory
@@ -1151,7 +1053,7 @@ To achieve this, run ``borg create`` within the mountpoint/snapshot directory:
 
     # Example: Some file system mounted in /mnt/rootfs.
     cd /mnt/rootfs
-    borg create /path/to/repo::rootfs_backup .
+    borg create rootfs_backup .
 
 
 I am having troubles with some network/FUSE/special filesystem, why?
@@ -1240,7 +1142,7 @@ This can happen for CIFS- or FUSE shares. If you are sure that your target volum
 will always have enough disk space, you can use the following workaround to disable
 checking for free disk space::
 
-    borg config -- $REPO_LOCATION additional_free_space -2T
+    borg config -- additional_free_space -2T
 
 How do I rename a repository?
 -----------------------------
@@ -1279,112 +1181,3 @@ libraries are actually loaded and used.
 In the borg git repository, there is scripts/glibc_check.py that can determine
 (based on the symbols' versions they want to link to) whether a set of given
 (Linux) binaries works with a given glibc version.
-
-
-Why was Borg forked from Attic?
--------------------------------
-
-Borg was created in May 2015 in response to the difficulty of getting new
-code or larger changes incorporated into Attic and establishing a bigger
-developer community / more open development.
-
-More details can be found in `ticket 217
-<https://github.com/jborg/attic/issues/217>`_ that led to the fork.
-
-Borg intends to be:
-
-* simple:
-
-  * as simple as possible, but no simpler
-  * do the right thing by default, but offer options
-* open:
-
-  * welcome feature requests
-  * accept pull requests of good quality and coding style
-  * give feedback on PRs that can't be accepted "as is"
-  * discuss openly, don't work in the dark
-* changing:
-
-  * Borg is not compatible with Attic
-  * do not break compatibility accidentally, without a good reason
-    or without warning. allow compatibility breaking for other cases.
-  * if major version number changes, it may have incompatible changes
-
-Migrating from Attic
-####################
-
-What are the differences between Attic and Borg?
-------------------------------------------------
-
-Borg is a fork of `Attic`_ and maintained by "`The Borg collective`_".
-
-.. _Attic: https://github.com/jborg/attic
-.. _The Borg collective: https://borgbackup.readthedocs.org/en/latest/authors.html
-
-Here's a (incomplete) list of some major changes:
-
-* lots of attic issues fixed
-  (see `issue #5 <https://github.com/borgbackup/borg/issues/5>`_),
-  including critical data corruption bugs and security issues.
-* more open, faster paced development
-  (see `issue #1 <https://github.com/borgbackup/borg/issues/1>`_)
-* less chunk management overhead (less memory and disk usage for chunks index)
-* faster remote cache resync (useful when backing up multiple machines into same repo)
-* compression: no, lz4, zstd, zlib or lzma compression, adjustable compression levels
-* repokey replaces problematic passphrase mode (you can't change the passphrase
-  nor the pbkdf2 iteration count in "passphrase" mode)
-* simple sparse file support, great for virtual machine disk files
-* can read special files (e.g. block devices) or from stdin, write to stdout
-* rename-based locking is more compatible than attic's posix locking
-* uses fadvise to not spoil / blow up the fs cache
-* better error messages / exception handling
-* better logging, screen output, progress indication
-* tested on misc. Linux systems, 32 and 64bit, FreeBSD, OpenBSD, NetBSD, macOS
-
-Please read the :ref:`changelog` (or ``docs/changes.rst`` in the source distribution) for more
-information.
-
-Borg is not compatible with original Attic (but there is a one-way conversion).
-
-How do I migrate from Attic to Borg?
-------------------------------------
-
-Use :ref:`borg_upgrade`. This is a one-way process that cannot be reversed.
-
-There are some caveats:
-
-- The upgrade can only be performed on local repositories.
-  It cannot be performed on remote repositories.
-
-- If the repository is in "keyfile" encryption mode, the keyfile must
-  exist locally or it must be manually moved after performing the upgrade:
-
-  1. Get the repository ID with ``borg config /path/to/repo id``.
-  2. Locate the attic key file at ``~/.attic/keys/``. The correct key for the
-     repository starts with the line ``ATTIC_KEY <repository id>``.
-  3. Copy the attic key file to ``~/.config/borg/keys/``
-  4. Change the first line from ``ATTIC_KEY ...`` to ``BORG_KEY ...``.
-  5. Verify that the repository is now accessible (e.g. ``borg list <repository>``).
-- Attic and Borg use different :ref:`"chunker params" <chunker-params>`.
-  This means that data added by Borg won't deduplicate with the existing data
-  stored by Attic. The effect is lessened if the files cache is used with Borg.
-- Repositories in "passphrase" mode *must* be migrated to "repokey" mode using
-  "borg key migrate-to-repokey" (only available in borg <= 1.2.x). Borg does not
-  support the "passphrase" mode in any other way.
-
-Why is my backup bigger than with attic?
-----------------------------------------
-
-Attic was rather unflexible when it comes to compression, it always
-compressed using zlib level 6 (no way to switch compression off or
-adjust the level or algorithm).
-
-The default in Borg is lz4, which is fast enough to not use significant CPU time
-in most cases, but can only achieve modest compression. It still compresses
-easily compressed data fairly well.
-
-Borg also offers zstd, zlib and lzma compression, choose wisely.
-
-Which choice is the best option depends on a number of factors, like
-bandwidth to the repository, how well the data compresses, available CPU
-power and so on.
diff --git a/docs/installation.rst b/docs/installation.rst
index 1ff657879..60b05e45d 100644
--- a/docs/installation.rst
+++ b/docs/installation.rst
@@ -177,8 +177,8 @@ following dependencies first:
 * optionally, if you wish to mount an archive as a FUSE filesystem, you need
   a FUSE implementation for Python:
 
-  - Either pyfuse3_ (preferably, newer and maintained) or llfuse_ (older,
-    unmaintained now). See also the BORG_FUSE_IMPL env variable.
+  - Either pyfuse3_ (preferably, newer) or llfuse_ (older).
+    See also the BORG_FUSE_IMPL env variable.
   - See setup.py about the version requirements.
 
 If you have troubles finding the right package names, have a look at the
diff --git a/docs/internals/data-structures.rst b/docs/internals/data-structures.rst
index 8de20761b..b494fde50 100644
--- a/docs/internals/data-structures.rst
+++ b/docs/internals/data-structures.rst
@@ -79,7 +79,7 @@ Normally the keys are computed like this::
 
   key = id = id_hash(unencrypted_data)
 
-The id_hash function depends on the :ref:`encryption mode <borg_init>`.
+The id_hash function depends on the :ref:`encryption mode <borg_rcreate>`.
 
 As the id / key is used for deduplication, id_hash must be a cryptographically
 strong hash or MAC.
@@ -736,7 +736,6 @@ The chunks cache is a key -> value mapping and contains:
 
   - reference count
   - size
-  - encrypted/compressed size
 
 The chunks cache is a HashIndex_. Due to some restrictions of HashIndex,
 the reference count of each given chunk is limited to a constant, MAX_VALUE
@@ -754,9 +753,9 @@ Here is the estimated memory usage of Borg - it's complicated::
   chunk_size ~= 2 ^ HASH_MASK_BITS  (for buzhash chunker, BLOCK_SIZE for fixed chunker)
   chunk_count ~= total_file_size / chunk_size
 
-  repo_index_usage = chunk_count * 40
+  repo_index_usage = chunk_count * 48
 
-  chunks_cache_usage = chunk_count * 44
+  chunks_cache_usage = chunk_count * 40
 
   files_cache_usage = total_file_count * 240 + chunk_count * 80
 
diff --git a/docs/internals/frontends.rst b/docs/internals/frontends.rst
index d0ebed48c..7ef96c788 100644
--- a/docs/internals/frontends.rst
+++ b/docs/internals/frontends.rst
@@ -208,7 +208,7 @@ Passphrase prompts should be handled differently. Use the environment variables
 and *BORG_NEW_PASSPHRASE* (see :ref:`env_vars` for reference) to pass passphrases to Borg, don't
 use the interactive passphrase prompts.
 
-When setting a new passphrase (:ref:`borg_init`, :ref:`borg_key_change-passphrase`) normally
+When setting a new passphrase (:ref:`borg_rcreate`, :ref:`borg_key_change-passphrase`) normally
 Borg prompts whether it should display the passphrase. This can be suppressed by setting
 the environment variable *BORG_DISPLAY_PASSPHRASE* to *no*.
 
@@ -252,7 +252,7 @@ last_modified
 The *encryption* key, if present, contains:
 
 mode
-    Textual encryption mode name (same as :ref:`borg_init` ``--encryption`` names)
+    Textual encryption mode name (same as :ref:`borg_rcreate` ``--encryption`` names)
 keyfile
     Path to the local key file used for access. Depending on *mode* this key may be absent.
 
diff --git a/docs/internals/security.rst b/docs/internals/security.rst
index 69f22a804..b7b247d0e 100644
--- a/docs/internals/security.rst
+++ b/docs/internals/security.rst
@@ -38,9 +38,6 @@ Under these circumstances Borg guarantees that the attacker cannot
 The attacker can always impose a denial of service per definition (he could
 forbid connections to the repository, or delete it entirely).
 
-When the above attack model is extended to include multiple clients
-independently updating the same repository, then Borg fails to provide
-confidentiality (i.e. guarantees 3) and 4) do not apply any more).
 
 .. _security_structural_auth:
 
@@ -78,7 +75,7 @@ the root node of a DAG through its edges, since the root node has no incoming ed
 
 With the scheme as described so far an attacker could easily replace the manifest,
 therefore Borg includes a tertiary authentication mechanism (TAM) that is applied
-to the manifest since version 1.0.9 (see :ref:`tam_vuln`).
+to the manifest (see :ref:`tam_vuln`).
 
 TAM works by deriving a separate key through HKDF_ from the other encryption and
 authentication keys and calculating the HMAC of the metadata to authenticate [#]_::
@@ -129,12 +126,12 @@ AEAD modes
 
 Modes: --encryption (repokey|keyfile)-[blake2-](aes-ocb|chacha20-poly1305)
 
-Supported: borg 1.3+
+Supported: borg 2.0+
 
 Encryption with these modes is based on AEAD ciphers (authenticated encryption
 with associated data) and session keys.
 
-Depending on the chosen mode (see :ref:`borg_init`) different AEAD ciphers are used:
+Depending on the chosen mode (see :ref:`borg_rcreate`) different AEAD ciphers are used:
 
 - AES-256-OCB - super fast, single-pass algorithm IF you have hw accelerated AES.
 - chacha20-poly1305 - very fast, purely software based AEAD cipher.
@@ -201,106 +198,13 @@ Legacy modes
 
 Modes: --encryption (repokey|keyfile)-[blake2]
 
-Supported: all borg versions, blake2 since 1.1
+Supported: borg < 2.0
 
-DEPRECATED. We strongly suggest you use the safer AEAD modes, see above.
+These were the AES-CTR based modes in previous borg versions.
 
-Encryption with these modes is based on the Encrypt-then-MAC construction,
-which is generally seen as the most robust way to create an authenticated
-encryption scheme from encryption and message authentication primitives.
+borg 2.0 does not support creating new repos using these modes,
+but ``borg transfer`` can still read such existing repos.
 
-Every operation (encryption, MAC / authentication, chunk ID derivation)
-uses independent, random keys generated by `os.urandom`_.
-
-Borg does not support unauthenticated encryption -- only authenticated encryption
-schemes are supported. No unauthenticated encryption schemes will be added
-in the future.
-
-Depending on the chosen mode (see :ref:`borg_init`) different primitives are used:
-
-- Legacy encryption modes use AES-256 in CTR mode. The
-  counter is added in plaintext, since it is needed for decryption,
-  and is also tracked locally on the client to avoid counter reuse.
-
-- The authentication primitive is either HMAC-SHA-256 or BLAKE2b-256
-  in a keyed mode. 
-
-  Both HMAC-SHA-256 and BLAKE2b have undergone extensive cryptanalysis  
-  and have proven secure against known attacks. The known vulnerability
-  of SHA-256 against length extension attacks does not apply to HMAC-SHA-256.
-  
-  The authentication primitive should be chosen based upon SHA hardware support.
-  With SHA hardware support, hmac-sha256 is likely to be much faster. 
-  If no hardware support is provided, Blake2b-256 will outperform hmac-sha256.
-  To find out if you have SHA hardware support, use::
-
-  $ borg benchmark cpu
-
-  The output will include an evaluation of cryptographic hashes/MACs like::
-
-  Cryptographic hashes / MACs ====================================
-  hmac-sha256              1GB        0.436s
-  blake2b-256              1GB        1.579s
-
-  Based upon your output, choose the primitive that is faster (in the above
-  example, hmac-sha256 is much faster, which indicates SHA hardware support).
-
-- The primitive used for authentication is always the same primitive
-  that is used for deriving the chunk ID, but they are always
-  used with independent keys.
-
-Encryption::
-
-    id = AUTHENTICATOR(id_key, data)
-    compressed = compress(data)
-
-    iv = reserve_iv()
-    encrypted = AES-256-CTR(enc_key, 8-null-bytes || iv, compressed)
-    authenticated = type-byte || AUTHENTICATOR(enc_hmac_key, encrypted) || iv || encrypted
-
-
-Decryption::
-
-    # Given: input *authenticated* data, possibly a *chunk-id* to assert
-    type-byte, mac, iv, encrypted = SPLIT(authenticated)
-
-    ASSERT(type-byte is correct)
-    ASSERT( CONSTANT-TIME-COMPARISON( mac, AUTHENTICATOR(enc_hmac_key, encrypted) ) )
-
-    decrypted = AES-256-CTR(enc_key, 8-null-bytes || iv, encrypted)
-    decompressed = decompress(decrypted)
-
-    ASSERT( CONSTANT-TIME-COMPARISON( chunk-id, AUTHENTICATOR(id_key, decompressed) ) )
-
-The client needs to track which counter values have been used, since
-encrypting a chunk requires a starting counter value and no two chunks
-may have overlapping counter ranges (otherwise the bitwise XOR of the
-overlapping plaintexts is revealed).
-
-The client does not directly track the counter value, because it
-changes often (with each encrypted chunk), instead it commits a
-"reservation" to the security database and the repository by taking
-the current counter value and adding 4 GiB / 16 bytes (the block size)
-to the counter. Thus the client only needs to commit a new reservation
-every few gigabytes of encrypted data.
-
-This mechanism also avoids reusing counter values in case the client
-crashes or the connection to the repository is severed, since any
-reservation would have been committed to both the security database
-and the repository before any data is encrypted. Borg uses its
-standard mechanism (SaveFile) to ensure that reservations are durable
-(on most hardware / storage systems), therefore a crash of the
-client's host would not impact tracking of reservations.
-
-However, this design is not infallible, and requires synchronization
-between clients, which is handled through the repository. Therefore in
-a multiple-client scenario a repository can trick a client into
-reusing counter values by ignoring counter reservations and replaying
-the manifest (which will fail if the client has seen a more recent
-manifest or has a more recent nonce reservation). If the repository is
-untrusted, but a trusted synchronization channel exists between
-clients, the security database could be synchronized between them over
-said trusted channel. This is not part of Borg's functionality.
 
 .. _key_encryption:
 
@@ -468,13 +372,12 @@ Compression and Encryption
 
 Combining encryption with compression can be insecure in some contexts (e.g. online protocols).
 
-There was some discussion about this in `github issue #1040`_ and for Borg some developers
+There was some discussion about this in :issue:`1040` and for Borg some developers
 concluded this is no problem at all, some concluded this is hard and extremely slow to exploit
 and thus no problem in practice.
 
 No matter what, there is always the option not to use compression if you are worried about this.
 
-.. _github issue #1040: https://github.com/borgbackup/borg/issues/1040
 
 Fingerprinting
 ==============
@@ -490,7 +393,7 @@ output of the chunker. The sizes of these stored chunks are influenced by the
 compression, encryption and authentication.
 
 buzhash chunker
-+++++++++++++++
+~~~~~~~~~~~~~~~
 
 The buzhash chunker chunks according to the input data, the chunker's
 parameters and the secret chunker seed (which all influence the chunk boundary
@@ -501,7 +404,7 @@ chunk (identical content / size as the original file), bigger files result in
 multiple chunks.
 
 fixed chunker
-+++++++++++++
+~~~~~~~~~~~~~
 
 This chunker yields fixed sized chunks, with optional support of a differently
 sized header chunk. The last chunk is not required to have the full block size
diff --git a/docs/man/borg-benchmark-cpu.1 b/docs/man/borg-benchmark-cpu.1
index e6c51936b..9c3f4e0d4 100644
--- a/docs/man/borg-benchmark-cpu.1
+++ b/docs/man/borg-benchmark-cpu.1
@@ -1,8 +1,5 @@
 .\" Man page generated from reStructuredText.
 .
-.TH BORG-BENCHMARK-CPU 1 "2022-04-14" "" "borg backup tool"
-.SH NAME
-borg-benchmark-cpu \- Benchmark CPU bound operations.
 .
 .nr rst2man-indent-level 0
 .
@@ -30,6 +27,9 @@ level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .in \\n[rst2man-indent\\n[rst2man-indent-level]]u
 ..
+.TH "BORG-BENCHMARK-CPU" 1 "2022-06-25" "" "borg backup tool"
+.SH NAME
+borg-benchmark-cpu \- Benchmark CPU bound operations.
 .SH SYNOPSIS
 .sp
 borg [common options] benchmark cpu [options]
@@ -39,8 +39,12 @@ This command benchmarks misc. CPU bound borg operations.
 .sp
 It creates input data in memory, runs the operation and then displays throughput.
 To reduce outside influence on the timings, please make sure to run this with:
-\- an otherwise as idle as possible machine
-\- enough free memory so there will be no slow down due to paging activity
+.INDENT 0.0
+.IP \(bu 2
+an otherwise as idle as possible machine
+.IP \(bu 2
+enough free memory so there will be no slow down due to paging activity
+.UNINDENT
 .SH OPTIONS
 .sp
 See \fIborg\-common(1)\fP for common options of Borg commands.
diff --git a/docs/man/borg-benchmark-crud.1 b/docs/man/borg-benchmark-crud.1
index efa4df554..89cd546ec 100644
--- a/docs/man/borg-benchmark-crud.1
+++ b/docs/man/borg-benchmark-crud.1
@@ -1,8 +1,5 @@
 .\" Man page generated from reStructuredText.
 .
-.TH BORG-BENCHMARK-CRUD 1 "2022-04-14" "" "borg backup tool"
-.SH NAME
-borg-benchmark-crud \- Benchmark Create, Read, Update, Delete for archives.
 .
 .nr rst2man-indent-level 0
 .
@@ -30,9 +27,12 @@ level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .in \\n[rst2man-indent\\n[rst2man-indent-level]]u
 ..
+.TH "BORG-BENCHMARK-CRUD" 1 "2022-06-25" "" "borg backup tool"
+.SH NAME
+borg-benchmark-crud \- Benchmark Create, Read, Update, Delete for archives.
 .SH SYNOPSIS
 .sp
-borg [common options] benchmark crud [options] REPOSITORY PATH
+borg [common options] benchmark crud [options] PATH
 .SH DESCRIPTION
 .sp
 This command benchmarks borg CRUD (create, read, update, delete) operations.
@@ -88,9 +88,6 @@ See \fIborg\-common(1)\fP for common options of Borg commands.
 .SS arguments
 .INDENT 0.0
 .TP
-.B REPOSITORY
-repository to use for benchmark (must exist)
-.TP
 .B PATH
 path were to create benchmark input data
 .UNINDENT
diff --git a/docs/man/borg-benchmark.1 b/docs/man/borg-benchmark.1
index 0cd5e90cb..c832a7925 100644
--- a/docs/man/borg-benchmark.1
+++ b/docs/man/borg-benchmark.1
@@ -1,8 +1,5 @@
 .\" Man page generated from reStructuredText.
 .
-.TH BORG-BENCHMARK 1 "2022-04-14" "" "borg backup tool"
-.SH NAME
-borg-benchmark \- benchmark command
 .
 .nr rst2man-indent-level 0
 .
@@ -30,6 +27,9 @@ level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .in \\n[rst2man-indent\\n[rst2man-indent-level]]u
 ..
+.TH "BORG-BENCHMARK" 1 "2022-06-25" "" "borg backup tool"
+.SH NAME
+borg-benchmark \- benchmark command
 .SH SYNOPSIS
 .nf
 borg [common options] benchmark crud ...
diff --git a/docs/man/borg-break-lock.1 b/docs/man/borg-break-lock.1
index bd01367c9..81c290601 100644
--- a/docs/man/borg-break-lock.1
+++ b/docs/man/borg-break-lock.1
@@ -1,8 +1,5 @@
 .\" Man page generated from reStructuredText.
 .
-.TH BORG-BREAK-LOCK 1 "2022-04-14" "" "borg backup tool"
-.SH NAME
-borg-break-lock \- Break the repository lock (e.g. in case it was left by a dead borg.
 .
 .nr rst2man-indent-level 0
 .
@@ -30,9 +27,12 @@ level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .in \\n[rst2man-indent\\n[rst2man-indent-level]]u
 ..
+.TH "BORG-BREAK-LOCK" 1 "2022-06-25" "" "borg backup tool"
+.SH NAME
+borg-break-lock \- Break the repository lock (e.g. in case it was left by a dead borg.
 .SH SYNOPSIS
 .sp
-borg [common options] break\-lock [options] [REPOSITORY]
+borg [common options] break\-lock [options]
 .SH DESCRIPTION
 .sp
 This command breaks the repository and cache locks.
@@ -41,12 +41,6 @@ trying to access the Cache or the Repository.
 .SH OPTIONS
 .sp
 See \fIborg\-common(1)\fP for common options of Borg commands.
-.SS arguments
-.INDENT 0.0
-.TP
-.B REPOSITORY
-repository for which to break the locks
-.UNINDENT
 .SH SEE ALSO
 .sp
 \fIborg\-common(1)\fP
diff --git a/docs/man/borg-check.1 b/docs/man/borg-check.1
index 0dfbc27b1..9ec8e69f9 100644
--- a/docs/man/borg-check.1
+++ b/docs/man/borg-check.1
@@ -1,8 +1,5 @@
 .\" Man page generated from reStructuredText.
 .
-.TH BORG-CHECK 1 "2022-04-14" "" "borg backup tool"
-.SH NAME
-borg-check \- Check repository consistency
 .
 .nr rst2man-indent-level 0
 .
@@ -30,9 +27,12 @@ level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .in \\n[rst2man-indent\\n[rst2man-indent-level]]u
 ..
+.TH "BORG-CHECK" 1 "2022-06-25" "" "borg backup tool"
+.SH NAME
+borg-check \- Check repository consistency
 .SH SYNOPSIS
 .sp
-borg [common options] check [options] [REPOSITORY_OR_ARCHIVE]
+borg [common options] check [options]
 .SH DESCRIPTION
 .sp
 The check command verifies the consistency of a repository and the corresponding archives.
@@ -126,28 +126,25 @@ slow.
 .SH OPTIONS
 .sp
 See \fIborg\-common(1)\fP for common options of Borg commands.
-.SS arguments
-.INDENT 0.0
-.TP
-.B REPOSITORY_OR_ARCHIVE
-repository or archive to check consistency of
-.UNINDENT
 .SS optional arguments
 .INDENT 0.0
 .TP
-.B \-\-repository\-only
+.BI \-\-name \ NAME
+specify the archive name
+.TP
+.B  \-\-repository\-only
 only perform repository checks
 .TP
-.B \-\-archives\-only
+.B  \-\-archives\-only
 only perform archives checks
 .TP
-.B \-\-verify\-data
+.B  \-\-verify\-data
 perform cryptographic archive data integrity verification (conflicts with \fB\-\-repository\-only\fP)
 .TP
-.B \-\-repair
+.B  \-\-repair
 attempt to repair any inconsistencies found
 .TP
-.B \-\-save\-space
+.B  \-\-save\-space
 work slower, but using less space
 .TP
 .BI \-\-max\-duration \ SECONDS
diff --git a/docs/man/borg-common.1 b/docs/man/borg-common.1
index 85b46e70f..5e960b713 100644
--- a/docs/man/borg-common.1
+++ b/docs/man/borg-common.1
@@ -1,8 +1,5 @@
 .\" Man page generated from reStructuredText.
 .
-.TH BORG-COMMON 1 "2022-04-14" "" "borg backup tool"
-.SH NAME
-borg-common \- Common options of Borg commands
 .
 .nr rst2man-indent-level 0
 .
@@ -30,49 +27,52 @@ level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .in \\n[rst2man-indent\\n[rst2man-indent-level]]u
 ..
+.TH "BORG-COMMON" 1 "2022-06-25" "" "borg backup tool"
+.SH NAME
+borg-common \- Common options of Borg commands
 .SH SYNOPSIS
 .INDENT 0.0
 .TP
-.B \-h\fP,\fB  \-\-help
+.B  \-h\fP,\fB  \-\-help
 show this help message and exit
 .TP
-.B \-\-critical
+.B  \-\-critical
 work on log level CRITICAL
 .TP
-.B \-\-error
+.B  \-\-error
 work on log level ERROR
 .TP
-.B \-\-warning
+.B  \-\-warning
 work on log level WARNING (default)
 .TP
-.B \-\-info\fP,\fB  \-v\fP,\fB  \-\-verbose
+.B  \-\-info\fP,\fB  \-v\fP,\fB  \-\-verbose
 work on log level INFO
 .TP
-.B \-\-debug
+.B  \-\-debug
 enable debug output, work on log level DEBUG
 .TP
 .BI \-\-debug\-topic \ TOPIC
 enable TOPIC debugging (can be specified multiple times). The logger path is borg.debug.<TOPIC> if TOPIC is not fully qualified.
 .TP
-.B \-p\fP,\fB  \-\-progress
+.B  \-p\fP,\fB  \-\-progress
 show progress information
 .TP
-.B \-\-iec
+.B  \-\-iec
 format using IEC units (1KiB = 1024B)
 .TP
-.B \-\-log\-json
+.B  \-\-log\-json
 Output one JSON object per log line instead of formatted text.
 .TP
 .BI \-\-lock\-wait \ SECONDS
 wait at most SECONDS for acquiring a repository/cache lock (default: 1).
 .TP
-.B \-\-bypass\-lock
+.B  \-\-bypass\-lock
 Bypass locking mechanism
 .TP
-.B \-\-show\-version
+.B  \-\-show\-version
 show/log the borg version
 .TP
-.B \-\-show\-rc
+.B  \-\-show\-rc
 show/log the return code (rc)
 .TP
 .BI \-\-umask \ M
@@ -93,7 +93,7 @@ deprecated, use \fB\-\-upload\-buffer\fP instead
 .BI \-\-upload\-buffer \ UPLOAD_BUFFER
 set network upload buffer size in MiB. (default: 0=no buffer)
 .TP
-.B \-\-consider\-part\-files
+.B  \-\-consider\-part\-files
 treat part files like normal files (e.g. to list/extract them)
 .TP
 .BI \-\-debug\-profile \ FILE
@@ -101,6 +101,9 @@ Write execution profile in Borg format into FILE. For local use a Python\-compat
 .TP
 .BI \-\-rsh \ RSH
 Use this command to connect to the \(aqborg serve\(aq process (default: \(aqssh\(aq)
+.TP
+.BI \-r \ REPO\fR,\fB \ \-\-repo \ REPO
+repository to use
 .UNINDENT
 .SH SEE ALSO
 .sp
diff --git a/docs/man/borg-compact.1 b/docs/man/borg-compact.1
index 79f8fc4e8..18d79ee76 100644
--- a/docs/man/borg-compact.1
+++ b/docs/man/borg-compact.1
@@ -1,8 +1,5 @@
 .\" Man page generated from reStructuredText.
 .
-.TH BORG-COMPACT 1 "2022-04-14" "" "borg backup tool"
-.SH NAME
-borg-compact \- compact segment files in the repository
 .
 .nr rst2man-indent-level 0
 .
@@ -30,9 +27,12 @@ level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .in \\n[rst2man-indent\\n[rst2man-indent-level]]u
 ..
+.TH "BORG-COMPACT" 1 "2022-06-25" "" "borg backup tool"
+.SH NAME
+borg-compact \- compact segment files in the repository
 .SH SYNOPSIS
 .sp
-borg [common options] compact [options] [REPOSITORY]
+borg [common options] compact [options]
 .SH DESCRIPTION
 .sp
 This command frees repository space by compacting segments.
@@ -60,16 +60,10 @@ See \fIseparate_compaction\fP in Additional Notes for more details.
 .SH OPTIONS
 .sp
 See \fIborg\-common(1)\fP for common options of Borg commands.
-.SS arguments
-.INDENT 0.0
-.TP
-.B REPOSITORY
-repository to compact
-.UNINDENT
 .SS optional arguments
 .INDENT 0.0
 .TP
-.B \-\-cleanup\-commits
+.B  \-\-cleanup\-commits
 cleanup commit\-only 17\-byte segment files
 .TP
 .BI \-\-threshold \ PERCENT
@@ -82,10 +76,7 @@ set minimum threshold for saved space in PERCENT (Default: 10)
 .nf
 .ft C
 # compact segments and free repo disk space
-$ borg compact /path/to/repo
-
-# same as above plus clean up 17byte commit\-only segments
-$ borg compact \-\-cleanup\-commits /path/to/repo
+$ borg compact
 .ft P
 .fi
 .UNINDENT
diff --git a/docs/man/borg-compression.1 b/docs/man/borg-compression.1
index a55a7dba7..ff348a7e3 100644
--- a/docs/man/borg-compression.1
+++ b/docs/man/borg-compression.1
@@ -1,8 +1,5 @@
 .\" Man page generated from reStructuredText.
 .
-.TH BORG-COMPRESSION 1 "2022-04-14" "" "borg backup tool"
-.SH NAME
-borg-compression \- Details regarding compression
 .
 .nr rst2man-indent-level 0
 .
@@ -30,6 +27,9 @@ level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .in \\n[rst2man-indent\\n[rst2man-indent-level]]u
 ..
+.TH "BORG-COMPRESSION" 1 "2022-06-25" "" "borg backup tool"
+.SH NAME
+borg-compression \- Details regarding compression
 .SH DESCRIPTION
 .sp
 It is no problem to mix different compression methods in one repo,
diff --git a/docs/man/borg-config.1 b/docs/man/borg-config.1
index 26ccffdd6..35cc426d9 100644
--- a/docs/man/borg-config.1
+++ b/docs/man/borg-config.1
@@ -1,8 +1,5 @@
 .\" Man page generated from reStructuredText.
 .
-.TH BORG-CONFIG 1 "2022-04-14" "" "borg backup tool"
-.SH NAME
-borg-config \- get, set, and delete values in a repository or cache config file
 .
 .nr rst2man-indent-level 0
 .
@@ -30,9 +27,12 @@ level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .in \\n[rst2man-indent\\n[rst2man-indent-level]]u
 ..
+.TH "BORG-CONFIG" 1 "2022-06-25" "" "borg backup tool"
+.SH NAME
+borg-config \- get, set, and delete values in a repository or cache config file
 .SH SYNOPSIS
 .sp
-borg [common options] config [options] [REPOSITORY] [NAME] [VALUE]
+borg [common options] config [options] [NAME] [VALUE]
 .SH DESCRIPTION
 .sp
 This command gets and sets options in a local repository or cache config file.
@@ -53,9 +53,6 @@ See \fIborg\-common(1)\fP for common options of Borg commands.
 .SS arguments
 .INDENT 0.0
 .TP
-.B REPOSITORY
-repository to configure
-.TP
 .B NAME
 name of config key
 .TP
@@ -65,13 +62,13 @@ new value for key
 .SS optional arguments
 .INDENT 0.0
 .TP
-.B \-c\fP,\fB  \-\-cache
+.B  \-c\fP,\fB  \-\-cache
 get and set values from the repo cache
 .TP
-.B \-d\fP,\fB  \-\-delete
+.B  \-d\fP,\fB  \-\-delete
 delete the key from the config file
 .TP
-.B \-l\fP,\fB  \-\-list
+.B  \-l\fP,\fB  \-\-list
 list the configuration of the repo
 .UNINDENT
 .SH EXAMPLES
@@ -90,13 +87,13 @@ making changes!
 .nf
 .ft C
 # find cache directory
-$ cd ~/.cache/borg/$(borg config /path/to/repo id)
+$ cd ~/.cache/borg/$(borg config id)
 
 # reserve some space
-$ borg config /path/to/repo additional_free_space 2G
+$ borg config additional_free_space 2G
 
 # make a repo append\-only
-$ borg config /path/to/repo append_only 1
+$ borg config append_only 1
 .ft P
 .fi
 .UNINDENT
diff --git a/docs/man/borg-create.1 b/docs/man/borg-create.1
index 887814626..7d36f0940 100644
--- a/docs/man/borg-create.1
+++ b/docs/man/borg-create.1
@@ -1,8 +1,5 @@
 .\" Man page generated from reStructuredText.
 .
-.TH BORG-CREATE 1 "2022-04-14" "" "borg backup tool"
-.SH NAME
-borg-create \- Create new archive
 .
 .nr rst2man-indent-level 0
 .
@@ -30,9 +27,12 @@ level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .in \\n[rst2man-indent\\n[rst2man-indent-level]]u
 ..
+.TH "BORG-CREATE" 1 "2022-06-25" "" "borg backup tool"
+.SH NAME
+borg-create \- Create new archive
 .SH SYNOPSIS
 .sp
-borg [common options] create [options] ARCHIVE [PATH...]
+borg [common options] create [options] NAME [PATH...]
 .SH DESCRIPTION
 .sp
 This command creates a backup archive containing all files found while recursively
@@ -126,8 +126,8 @@ See \fIborg\-common(1)\fP for common options of Borg commands.
 .SS arguments
 .INDENT 0.0
 .TP
-.B ARCHIVE
-name of archive to create (must be also a valid directory name)
+.B NAME
+specify the archive name
 .TP
 .B PATH
 paths to archive
@@ -135,22 +135,22 @@ paths to archive
 .SS optional arguments
 .INDENT 0.0
 .TP
-.B \-n\fP,\fB  \-\-dry\-run
+.B  \-n\fP,\fB  \-\-dry\-run
 do not create a backup archive
 .TP
-.B \-s\fP,\fB  \-\-stats
+.B  \-s\fP,\fB  \-\-stats
 print statistics for the created archive
 .TP
-.B \-\-list
+.B  \-\-list
 output verbose list of items (files, dirs, ...)
 .TP
 .BI \-\-filter \ STATUSCHARS
 only display items with the given status characters (see description)
 .TP
-.B \-\-json
+.B  \-\-json
 output stats as JSON. Implies \fB\-\-stats\fP\&.
 .TP
-.B \-\-no\-cache\-sync
+.B  \-\-no\-cache\-sync
 experimental: do not synchronize the cache. Implies not using the files cache.
 .TP
 .BI \-\-stdin\-name \ NAME
@@ -160,18 +160,18 @@ use NAME in archive for stdin data (default: \(aqstdin\(aq)
 set user USER in archive for stdin data (default: \(aqroot\(aq)
 .TP
 .BI \-\-stdin\-group \ GROUP
-set group GROUP in archive for stdin data (default: \(aqroot\(aq)
+set group GROUP in archive for stdin data (default: \(aqwheel\(aq)
 .TP
 .BI \-\-stdin\-mode \ M
 set mode to M in archive for stdin data (default: 0660)
 .TP
-.B \-\-content\-from\-command
+.B  \-\-content\-from\-command
 interpret PATH as command and store its stdout. See also section Reading from stdin below.
 .TP
-.B \-\-paths\-from\-stdin
+.B  \-\-paths\-from\-stdin
 read DELIM\-separated list of paths to backup from stdin. Will not recurse into directories.
 .TP
-.B \-\-paths\-from\-command
+.B  \-\-paths\-from\-command
 interpret PATH as command and treat its output as \fB\-\-paths\-from\-stdin\fP
 .TP
 .BI \-\-paths\-delimiter \ DELIM
@@ -192,61 +192,61 @@ include/exclude paths matching PATTERN
 .BI \-\-patterns\-from \ PATTERNFILE
 read include/exclude patterns from PATTERNFILE, one per line
 .TP
-.B \-\-exclude\-caches
+.B  \-\-exclude\-caches
 exclude directories that contain a CACHEDIR.TAG file (\fI\%http://www.bford.info/cachedir/spec.html\fP)
 .TP
 .BI \-\-exclude\-if\-present \ NAME
 exclude directories that are tagged by containing a filesystem object with the given NAME
 .TP
-.B \-\-keep\-exclude\-tags
+.B  \-\-keep\-exclude\-tags
 if tag objects are specified with \fB\-\-exclude\-if\-present\fP, don\(aqt omit the tag objects themselves from the backup archive
 .TP
-.B \-\-exclude\-nodump
+.B  \-\-exclude\-nodump
 exclude files flagged NODUMP
 .UNINDENT
 .SS Filesystem options
 .INDENT 0.0
 .TP
-.B \-x\fP,\fB  \-\-one\-file\-system
+.B  \-x\fP,\fB  \-\-one\-file\-system
 stay in the same file system and do not store mount points of other file systems.  This might behave different from your expectations, see the docs.
 .TP
-.B \-\-numeric\-owner
+.B  \-\-numeric\-owner
 deprecated, use \fB\-\-numeric\-ids\fP instead
 .TP
-.B \-\-numeric\-ids
+.B  \-\-numeric\-ids
 only store numeric user and group identifiers
 .TP
-.B \-\-noatime
+.B  \-\-noatime
 do not store atime into archive
 .TP
-.B \-\-atime
+.B  \-\-atime
 do store atime into archive
 .TP
-.B \-\-noctime
+.B  \-\-noctime
 do not store ctime into archive
 .TP
-.B \-\-nobirthtime
+.B  \-\-nobirthtime
 do not store birthtime (creation date) into archive
 .TP
-.B \-\-nobsdflags
+.B  \-\-nobsdflags
 deprecated, use \fB\-\-noflags\fP instead
 .TP
-.B \-\-noflags
+.B  \-\-noflags
 do not read and store flags (e.g. NODUMP, IMMUTABLE) into archive
 .TP
-.B \-\-noacls
+.B  \-\-noacls
 do not read and store ACLs into archive
 .TP
-.B \-\-noxattrs
+.B  \-\-noxattrs
 do not read and store xattrs into archive
 .TP
-.B \-\-sparse
+.B  \-\-sparse
 detect sparse holes in input (supported only by fixed chunker)
 .TP
 .BI \-\-files\-cache \ MODE
 operate files cache in MODE. default: ctime,size,inode
 .TP
-.B \-\-read\-special
+.B  \-\-read\-special
 open and read block and char device files as well as FIFOs as if they were regular files. Also follows symlinks pointing to these kinds of files.
 .UNINDENT
 .SS Archive options
@@ -274,86 +274,84 @@ select compression algorithm, see the output of the "borg help compression" comm
 .nf
 .ft C
 # Backup ~/Documents into an archive named "my\-documents"
-$ borg create /path/to/repo::my\-documents ~/Documents
+$ borg create my\-documents ~/Documents
 
 # same, but list all files as we process them
-$ borg create \-\-list /path/to/repo::my\-documents ~/Documents
+$ borg create \-\-list my\-documents ~/Documents
 
 # Backup ~/Documents and ~/src but exclude pyc files
-$ borg create /path/to/repo::my\-files \e
+$ borg create my\-files                \e
     ~/Documents                       \e
     ~/src                             \e
     \-\-exclude \(aq*.pyc\(aq
 
 # Backup home directories excluding image thumbnails (i.e. only
 # /home/<one directory>/.thumbnails is excluded, not /home/*/*/.thumbnails etc.)
-$ borg create /path/to/repo::my\-files /home \e
-    \-\-exclude \(aqsh:/home/*/.thumbnails\(aq
+$ borg create my\-files /home \-\-exclude \(aqsh:home/*/.thumbnails\(aq
 
 # Backup the root filesystem into an archive named "root\-YYYY\-MM\-DD"
 # use zlib compression (good, but slow) \- default is lz4 (fast, low compression ratio)
-$ borg create \-C zlib,6 \-\-one\-file\-system /path/to/repo::root\-{now:%Y\-%m\-%d} /
+$ borg create \-C zlib,6 \-\-one\-file\-system root\-{now:%Y\-%m\-%d} /
 
-# Backup onto a remote host ("push" style) via ssh to port 2222,
-# logging in as user "borg" and storing into /path/to/repo
-$ borg create ssh://borg@backup.example.org:2222/path/to/repo::{fqdn}\-root\-{now} /
+# Backup into an archive name like FQDN\-root\-TIMESTAMP
+$ borg create \(aq{fqdn}\-root\-{now}\(aq /
 
 # Backup a remote host locally ("pull" style) using sshfs
 $ mkdir sshfs\-mount
 $ sshfs root@example.com:/ sshfs\-mount
 $ cd sshfs\-mount
-$ borg create /path/to/repo::example.com\-root\-{now:%Y\-%m\-%d} .
+$ borg create example.com\-root\-{now:%Y\-%m\-%d} .
 $ cd ..
 $ fusermount \-u sshfs\-mount
 
 # Make a big effort in fine granular deduplication (big chunk management
 # overhead, needs a lot of RAM and disk space, see formula in internals
 # docs \- same parameters as borg < 1.0 or attic):
-$ borg create \-\-chunker\-params buzhash,10,23,16,4095 /path/to/repo::small /smallstuff
+$ borg create \-\-chunker\-params buzhash,10,23,16,4095 small /smallstuff
 
 # Backup a raw device (must not be active/in use/mounted at that time)
-$ borg create \-\-read\-special \-\-chunker\-params fixed,4194304 /path/to/repo::my\-sdx /dev/sdX
+$ borg create \-\-read\-special \-\-chunker\-params fixed,4194304 my\-sdx /dev/sdX
 
 # Backup a sparse disk image (must not be active/in use/mounted at that time)
-$ borg create \-\-sparse \-\-chunker\-params fixed,4194304 /path/to/repo::my\-disk my\-disk.raw
+$ borg create \-\-sparse \-\-chunker\-params fixed,4194304 my\-disk my\-disk.raw
 
 # No compression (none)
-$ borg create \-\-compression none /path/to/repo::arch ~
+$ borg create \-\-compression none arch ~
 
 # Super fast, low compression (lz4, default)
-$ borg create /path/to/repo::arch ~
+$ borg create arch ~
 
 # Less fast, higher compression (zlib, N = 0..9)
-$ borg create \-\-compression zlib,N /path/to/repo::arch ~
+$ borg create \-\-compression zlib,N arch ~
 
 # Even slower, even higher compression (lzma, N = 0..9)
-$ borg create \-\-compression lzma,N /path/to/repo::arch ~
+$ borg create \-\-compression lzma,N arch ~
 
 # Only compress compressible data with lzma,N (N = 0..9)
-$ borg create \-\-compression auto,lzma,N /path/to/repo::arch ~
+$ borg create \-\-compression auto,lzma,N arch ~
 
 # Use short hostname, user name and current time in archive name
-$ borg create /path/to/repo::{hostname}\-{user}\-{now} ~
+$ borg create \(aq{hostname}\-{user}\-{now}\(aq ~
 # Similar, use the same datetime format that is default as of borg 1.1
-$ borg create /path/to/repo::{hostname}\-{user}\-{now:%Y\-%m\-%dT%H:%M:%S} ~
+$ borg create \(aq{hostname}\-{user}\-{now:%Y\-%m\-%dT%H:%M:%S}\(aq ~
 # As above, but add nanoseconds
-$ borg create /path/to/repo::{hostname}\-{user}\-{now:%Y\-%m\-%dT%H:%M:%S.%f} ~
+$ borg create \(aq{hostname}\-{user}\-{now:%Y\-%m\-%dT%H:%M:%S.%f}\(aq ~
 
 # Backing up relative paths by moving into the correct directory first
 $ cd /home/user/Documents
 # The root directory of the archive will be "projectA"
-$ borg create /path/to/repo::daily\-projectA\-{now:%Y\-%m\-%d} projectA
+$ borg create \(aqdaily\-projectA\-{now:%Y\-%m\-%d}\(aq projectA
 
 # Use external command to determine files to archive
 # Use \-\-paths\-from\-stdin with find to only backup files less than 1MB in size
-$ find ~ \-size \-1000k | borg create \-\-paths\-from\-stdin /path/to/repo::small\-files\-only
+$ find ~ \-size \-1000k | borg create \-\-paths\-from\-stdin small\-files\-only
 # Use \-\-paths\-from\-command with find to only backup files from a given user
-$ borg create \-\-paths\-from\-command /path/to/repo::joes\-files \-\- find /srv/samba/shared \-user joe
+$ borg create \-\-paths\-from\-command joes\-files \-\- find /srv/samba/shared \-user joe
 # Use \-\-paths\-from\-stdin with \-\-paths\-delimiter (for example, for filenames with newlines in them)
 $ find ~ \-size \-1000k \-print0 | borg create \e
     \-\-paths\-from\-stdin \e
     \-\-paths\-delimiter "\e0" \e
-    /path/to/repo::smallfiles\-handle\-newline
+    smallfiles\-handle\-newline
 .ft P
 .fi
 .UNINDENT
diff --git a/docs/man/borg-delete.1 b/docs/man/borg-delete.1
index 68639c1ea..7a213de1d 100644
--- a/docs/man/borg-delete.1
+++ b/docs/man/borg-delete.1
@@ -1,8 +1,5 @@
 .\" Man page generated from reStructuredText.
 .
-.TH BORG-DELETE 1 "2022-04-14" "" "borg backup tool"
-.SH NAME
-borg-delete \- Delete an existing repository or archives
 .
 .nr rst2man-indent-level 0
 .
@@ -30,21 +27,19 @@ level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .in \\n[rst2man-indent\\n[rst2man-indent-level]]u
 ..
+.TH "BORG-DELETE" 1 "2022-06-25" "" "borg backup tool"
+.SH NAME
+borg-delete \- Delete archives
 .SH SYNOPSIS
 .sp
-borg [common options] delete [options] [REPOSITORY_OR_ARCHIVE] [ARCHIVE...]
+borg [common options] delete [options]
 .SH DESCRIPTION
 .sp
-This command deletes an archive from the repository or the complete repository.
+This command deletes archives from the repository.
 .sp
 Important: When deleting archives, repository disk space is \fBnot\fP freed until
 you run \fBborg compact\fP\&.
 .sp
-When you delete a complete repository, the security info and local cache for it
-(if any) are also deleted. Alternatively, you can delete just the local cache
-with the \fB\-\-cache\-only\fP option, or keep the security info with the
-\fB\-\-keep\-security\-info\fP option.
-.sp
 When in doubt, use \fB\-\-dry\-run \-\-list\fP to see what would be deleted.
 .sp
 When using \fB\-\-stats\fP, you will get some statistics about how much data was
@@ -58,43 +53,35 @@ pattern to match multiple archives using the \fB\-\-glob\-archives GLOB\fP optio
 (for more info on these patterns, see \fIborg_patterns\fP). Note that these
 two options are mutually exclusive.
 .sp
-To avoid accidentally deleting archives, especially when using glob patterns,
-it might be helpful to use the \fB\-\-dry\-run\fP to test out the command without
-actually making any changes to the repository.
+Always first use \fB\-\-dry\-run \-\-list\fP to see what would be deleted.
 .SH OPTIONS
 .sp
 See \fIborg\-common(1)\fP for common options of Borg commands.
-.SS arguments
-.INDENT 0.0
-.TP
-.B REPOSITORY_OR_ARCHIVE
-repository or archive to delete
-.TP
-.B ARCHIVE
-archives to delete
-.UNINDENT
 .SS optional arguments
 .INDENT 0.0
 .TP
-.B \-n\fP,\fB  \-\-dry\-run
+.B  \-n\fP,\fB  \-\-dry\-run
 do not change repository
 .TP
-.B \-\-list
+.B  \-\-list
 output verbose list of archives
 .TP
-.B \-s\fP,\fB  \-\-stats
+.B  \-\-consider\-checkpoints
+consider checkpoint archives for deletion (default: not considered).
+.TP
+.B  \-s\fP,\fB  \-\-stats
 print statistics for the deleted archive
 .TP
-.B \-\-cache\-only
+.B  \-\-cache\-only
 delete only the local cache for the given repository
 .TP
-.B \-\-force
+.B  \-\-force
 force deletion of corrupted archives, use \fB\-\-force \-\-force\fP in case \fB\-\-force\fP does not work.
 .TP
-.B \-\-keep\-security\-info
+.B  \-\-keep\-security\-info
 keep the local security info when deleting a repository
 .TP
-.B \-\-save\-space
+.B  \-\-save\-space
 work slower, but using less space
 .UNINDENT
 .SS Archive filters
@@ -122,26 +109,18 @@ consider last N archives after other filters were applied
 .nf
 .ft C
 # delete a single backup archive:
-$ borg delete /path/to/repo::Monday
+$ borg delete Monday
 # actually free disk space:
-$ borg compact /path/to/repo
+$ borg compact
 
 # delete all archives whose names begin with the machine\(aqs hostname followed by "\-"
-$ borg delete \-\-prefix \(aq{hostname}\-\(aq /path/to/repo
+$ borg delete \-\-prefix \(aq{hostname}\-\(aq
 
 # delete all archives whose names contain "\-2012\-"
-$ borg delete \-\-glob\-archives \(aq*\-2012\-*\(aq /path/to/repo
+$ borg delete \-a \(aq*\-2012\-*\(aq
 
 # see what would be deleted if delete was run without \-\-dry\-run
-$ borg delete \-\-list \-\-dry\-run \-a \(aq*\-May\-*\(aq /path/to/repo
-
-# delete the whole repository and the related local cache:
-$ borg delete /path/to/repo
-You requested to completely DELETE the repository *including* all archives it contains:
-repo                                 Mon, 2016\-02\-15 19:26:54
-root\-2016\-02\-15                      Mon, 2016\-02\-15 19:36:29
-newname                              Mon, 2016\-02\-15 19:50:19
-Type \(aqYES\(aq if you understand this and want to continue: YES
+$ borg delete \-\-list \-\-dry\-run \-a \(aq*\-May\-*\(aq
 .ft P
 .fi
 .UNINDENT
diff --git a/docs/man/borg-diff.1 b/docs/man/borg-diff.1
index 2ccf05e03..27b026d29 100644
--- a/docs/man/borg-diff.1
+++ b/docs/man/borg-diff.1
@@ -1,8 +1,5 @@
 .\" Man page generated from reStructuredText.
 .
-.TH BORG-DIFF 1 "2022-04-14" "" "borg backup tool"
-.SH NAME
-borg-diff \- Diff contents of two archives
 .
 .nr rst2man-indent-level 0
 .
@@ -30,9 +27,12 @@ level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .in \\n[rst2man-indent\\n[rst2man-indent-level]]u
 ..
+.TH "BORG-DIFF" 1 "2022-06-25" "" "borg backup tool"
+.SH NAME
+borg-diff \- Diff contents of two archives
 .SH SYNOPSIS
 .sp
-borg [common options] diff [options] REPO::ARCHIVE1 ARCHIVE2 [PATH...]
+borg [common options] diff [options] ARCHIVE1 ARCHIVE2 [PATH...]
 .SH DESCRIPTION
 .sp
 This command finds differences (file contents, user/group/mode) between archives.
@@ -57,11 +57,11 @@ See \fIborg\-common(1)\fP for common options of Borg commands.
 .SS arguments
 .INDENT 0.0
 .TP
-.B REPO::ARCHIVE1
-repository location and ARCHIVE1 name
+.B ARCHIVE1
+ARCHIVE1 name
 .TP
 .B ARCHIVE2
-ARCHIVE2 name (no repository location allowed)
+ARCHIVE2 name
 .TP
 .B PATH
 paths of items inside the archives to compare; patterns are supported
@@ -69,19 +69,19 @@ paths of items inside the archives to compare; patterns are supported
 .SS optional arguments
 .INDENT 0.0
 .TP
-.B \-\-numeric\-owner
+.B  \-\-numeric\-owner
 deprecated, use \fB\-\-numeric\-ids\fP instead
 .TP
-.B \-\-numeric\-ids
+.B  \-\-numeric\-ids
 only consider numeric user and group identifiers
 .TP
-.B \-\-same\-chunker\-params
+.B  \-\-same\-chunker\-params
 Override check of chunker parameters.
 .TP
-.B \-\-sort
+.B  \-\-sort
 Sort the output lines by file path.
 .TP
-.B \-\-json\-lines
+.B  \-\-json\-lines
 Format output as JSON Lines.
 .UNINDENT
 .SS Exclusion options
@@ -105,44 +105,17 @@ read include/exclude patterns from PATTERNFILE, one per line
 .sp
 .nf
 .ft C
-$ borg init \-e=none testrepo
-$ mkdir testdir
-$ cd testdir
-$ echo asdf > file1
-$ dd if=/dev/urandom bs=1M count=4 > file2
-$ touch file3
-$ borg create ../testrepo::archive1 .
-
-$ chmod a+x file1
-$ echo "something" >> file2
-$ borg create ../testrepo::archive2 .
-
-$ echo "testing 123" >> file1
-$ rm file3
-$ touch file4
-$ borg create ../testrepo::archive3 .
-
-$ cd ..
-$ borg diff testrepo::archive1 archive2
-[\-rw\-r\-\-r\-\- \-> \-rwxr\-xr\-x] file1
-   +135 B    \-252 B file2
-
-$ borg diff testrepo::archive2 archive3
-    +17 B      \-5 B file1
-added           0 B file4
-removed         0 B file3
-
-$ borg diff testrepo::archive1 archive3
+$ borg diff archive1 archive2
     +17 B      \-5 B [\-rw\-r\-\-r\-\- \-> \-rwxr\-xr\-x] file1
    +135 B    \-252 B file2
 added           0 B file4
 removed         0 B file3
 
-$ borg diff \-\-json\-lines testrepo::archive1 archive3
+$ borg diff archive1 archive2
 {"path": "file1", "changes": [{"type": "modified", "added": 17, "removed": 5}, {"type": "mode", "old_mode": "\-rw\-r\-\-r\-\-", "new_mode": "\-rwxr\-xr\-x"}]}
 {"path": "file2", "changes": [{"type": "modified", "added": 135, "removed": 252}]}
 {"path": "file4", "changes": [{"type": "added", "size": 0}]}
-{"path": "file3", "changes": [{"type": "removed", "size": 0}]
+{"path": "file3", "changes": [{"type": "removed", "size": 0}]}
 .ft P
 .fi
 .UNINDENT
diff --git a/docs/man/borg-export-tar.1 b/docs/man/borg-export-tar.1
index 437aad535..93900a558 100644
--- a/docs/man/borg-export-tar.1
+++ b/docs/man/borg-export-tar.1
@@ -1,8 +1,5 @@
 .\" Man page generated from reStructuredText.
 .
-.TH BORG-EXPORT-TAR 1 "2022-04-14" "" "borg backup tool"
-.SH NAME
-borg-export-tar \- Export archive contents as a tarball
 .
 .nr rst2man-indent-level 0
 .
@@ -30,9 +27,12 @@ level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .in \\n[rst2man-indent\\n[rst2man-indent-level]]u
 ..
+.TH "BORG-EXPORT-TAR" 1 "2022-06-25" "" "borg backup tool"
+.SH NAME
+borg-export-tar \- Export archive contents as a tarball
 .SH SYNOPSIS
 .sp
-borg [common options] export\-tar [options] ARCHIVE FILE [PATH...]
+borg [common options] export\-tar [options] NAME FILE [PATH...]
 .SH DESCRIPTION
 .sp
 This command creates a tarball from an archive.
@@ -115,8 +115,8 @@ See \fIborg\-common(1)\fP for common options of Borg commands.
 .SS arguments
 .INDENT 0.0
 .TP
-.B ARCHIVE
-archive to export
+.B NAME
+specify the archive name
 .TP
 .B FILE
 output tar file. "\-" to write to stdout instead.
@@ -127,10 +127,10 @@ paths to extract; patterns are supported
 .SS optional arguments
 .INDENT 0.0
 .TP
-.B \-\-tar\-filter
+.B  \-\-tar\-filter
 filter program to pipe data through
 .TP
-.B \-\-list
+.B  \-\-list
 output verbose list of items (files, dirs, ...)
 .TP
 .BI \-\-tar\-format \ FMT
diff --git a/docs/man/borg-extract.1 b/docs/man/borg-extract.1
index 69d2a0e41..a5e70b1fd 100644
--- a/docs/man/borg-extract.1
+++ b/docs/man/borg-extract.1
@@ -1,8 +1,5 @@
 .\" Man page generated from reStructuredText.
 .
-.TH BORG-EXTRACT 1 "2022-04-14" "" "borg backup tool"
-.SH NAME
-borg-extract \- Extract archive contents
 .
 .nr rst2man-indent-level 0
 .
@@ -30,9 +27,12 @@ level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .in \\n[rst2man-indent\\n[rst2man-indent-level]]u
 ..
+.TH "BORG-EXTRACT" 1 "2022-06-25" "" "borg backup tool"
+.SH NAME
+borg-extract \- Extract archive contents
 .SH SYNOPSIS
 .sp
-borg [common options] extract [options] ARCHIVE [PATH...]
+borg [common options] extract [options] NAME [PATH...]
 .SH DESCRIPTION
 .sp
 This command extracts the contents of an archive. By default the entire
@@ -66,8 +66,8 @@ See \fIborg\-common(1)\fP for common options of Borg commands.
 .SS arguments
 .INDENT 0.0
 .TP
-.B ARCHIVE
-archive to extract
+.B NAME
+specify the archive name
 .TP
 .B PATH
 paths to extract; patterns are supported
@@ -75,34 +75,34 @@ paths to extract; patterns are supported
 .SS optional arguments
 .INDENT 0.0
 .TP
-.B \-\-list
+.B  \-\-list
 output verbose list of items (files, dirs, ...)
 .TP
-.B \-n\fP,\fB  \-\-dry\-run
+.B  \-n\fP,\fB  \-\-dry\-run
 do not actually change any files
 .TP
-.B \-\-numeric\-owner
+.B  \-\-numeric\-owner
 deprecated, use \fB\-\-numeric\-ids\fP instead
 .TP
-.B \-\-numeric\-ids
+.B  \-\-numeric\-ids
 only obey numeric user and group identifiers
 .TP
-.B \-\-nobsdflags
+.B  \-\-nobsdflags
 deprecated, use \fB\-\-noflags\fP instead
 .TP
-.B \-\-noflags
+.B  \-\-noflags
 do not extract/set flags (e.g. NODUMP, IMMUTABLE)
 .TP
-.B \-\-noacls
+.B  \-\-noacls
 do not extract/set ACLs
 .TP
-.B \-\-noxattrs
+.B  \-\-noxattrs
 do not extract/set xattrs
 .TP
-.B \-\-stdout
+.B  \-\-stdout
 write all extracted data to stdout
 .TP
-.B \-\-sparse
+.B  \-\-sparse
 create holes in output sparse file from all\-zero chunks
 .UNINDENT
 .SS Exclusion options
@@ -130,22 +130,22 @@ Remove the specified number of leading path elements. Paths with fewer elements
 .nf
 .ft C
 # Extract entire archive
-$ borg extract /path/to/repo::my\-files
+$ borg extract my\-files
 
 # Extract entire archive and list files while processing
-$ borg extract \-\-list /path/to/repo::my\-files
+$ borg extract \-\-list my\-files
 
 # Verify whether an archive could be successfully extracted, but do not write files to disk
-$ borg extract \-\-dry\-run /path/to/repo::my\-files
+$ borg extract \-\-dry\-run my\-files
 
 # Extract the "src" directory
-$ borg extract /path/to/repo::my\-files home/USERNAME/src
+$ borg extract my\-files home/USERNAME/src
 
 # Extract the "src" directory but exclude object files
-$ borg extract /path/to/repo::my\-files home/USERNAME/src \-\-exclude \(aq*.o\(aq
+$ borg extract my\-files home/USERNAME/src \-\-exclude \(aq*.o\(aq
 
 # Restore a raw device (must not be active/in use/mounted at that time)
-$ borg extract \-\-stdout /path/to/repo::my\-sdx | dd of=/dev/sdx bs=10M
+$ borg extract \-\-stdout my\-sdx | dd of=/dev/sdx bs=10M
 .ft P
 .fi
 .UNINDENT
diff --git a/docs/man/borg-import-tar.1 b/docs/man/borg-import-tar.1
index dc8439775..9af05ce3b 100644
--- a/docs/man/borg-import-tar.1
+++ b/docs/man/borg-import-tar.1
@@ -1,8 +1,5 @@
 .\" Man page generated from reStructuredText.
 .
-.TH BORG-IMPORT-TAR 1 "2022-04-14" "" "borg backup tool"
-.SH NAME
-borg-import-tar \- Create a backup archive from a tarball
 .
 .nr rst2man-indent-level 0
 .
@@ -30,9 +27,12 @@ level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .in \\n[rst2man-indent\\n[rst2man-indent-level]]u
 ..
+.TH "BORG-IMPORT-TAR" 1 "2022-06-25" "" "borg backup tool"
+.SH NAME
+borg-import-tar \- Create a backup archive from a tarball
 .SH SYNOPSIS
 .sp
-borg [common options] import\-tar [options] ARCHIVE TARFILE
+borg [common options] import\-tar [options] NAME TARFILE
 .SH DESCRIPTION
 .sp
 This command creates a backup archive from a tarball.
@@ -86,8 +86,8 @@ See \fIborg\-common(1)\fP for common options of Borg commands.
 .SS arguments
 .INDENT 0.0
 .TP
-.B ARCHIVE
-name of archive to create (must be also a valid directory name)
+.B NAME
+specify the archive name
 .TP
 .B TARFILE
 input tar file. "\-" to read from stdin instead.
@@ -95,19 +95,19 @@ input tar file. "\-" to read from stdin instead.
 .SS optional arguments
 .INDENT 0.0
 .TP
-.B \-\-tar\-filter
+.B  \-\-tar\-filter
 filter program to pipe data through
 .TP
-.B \-s\fP,\fB  \-\-stats
+.B  \-s\fP,\fB  \-\-stats
 print statistics for the created archive
 .TP
-.B \-\-list
+.B  \-\-list
 output verbose list of items (files, dirs, ...)
 .TP
 .BI \-\-filter \ STATUSCHARS
 only display items with the given status characters
 .TP
-.B \-\-json
+.B  \-\-json
 output stats as JSON (implies \-\-stats)
 .UNINDENT
 .SS Archive options
@@ -135,25 +135,25 @@ select compression algorithm, see the output of the "borg help compression" comm
 .nf
 .ft C
 # export as uncompressed tar
-$ borg export\-tar /path/to/repo::Monday Monday.tar
+$ borg export\-tar Monday Monday.tar
 
 # import an uncompressed tar
-$ borg import\-tar /path/to/repo::Monday Monday.tar
+$ borg import\-tar Monday Monday.tar
 
 # exclude some file types, compress using gzip
-$ borg export\-tar /path/to/repo::Monday Monday.tar.gz \-\-exclude \(aq*.so\(aq
+$ borg export\-tar Monday Monday.tar.gz \-\-exclude \(aq*.so\(aq
 
 # use higher compression level with gzip
-$ borg export\-tar \-\-tar\-filter="gzip \-9" repo::Monday Monday.tar.gz
+$ borg export\-tar \-\-tar\-filter="gzip \-9" Monday Monday.tar.gz
 
 # copy an archive from repoA to repoB
-$ borg export\-tar \-\-tar\-format=BORG repoA::archive \- | borg import\-tar repoB::archive \-
+$ borg \-r repoA export\-tar \-\-tar\-format=BORG archive \- | borg \-r repoB import\-tar archive \-
 
 # export a tar, but instead of storing it on disk, upload it to remote site using curl
-$ borg export\-tar /path/to/repo::Monday \- | curl \-\-data\-binary @\- https://somewhere/to/POST
+$ borg export\-tar Monday \- | curl \-\-data\-binary @\- https://somewhere/to/POST
 
 # remote extraction via "tarpipe"
-$ borg export\-tar /path/to/repo::Monday \- | ssh somewhere "cd extracted; tar x"
+$ borg export\-tar Monday \- | ssh somewhere "cd extracted; tar x"
 .ft P
 .fi
 .UNINDENT
@@ -166,9 +166,9 @@ Outputs a script that copies all archives from repo1 to repo2:
 .sp
 .nf
 .ft C
-for A T in \(gaborg list \-\-format=\(aq{archive} {time:%Y\-%m\-%dT%H:%M:%S}{LF}\(aq repo1\(ga
+for A T in \(gaborg list \-\-format=\(aq{archive} {time:%Y\-%m\-%dT%H:%M:%S}{LF}\(aq\(ga
 do
-  echo "borg export\-tar \-\-tar\-format=BORG repo1::$A \- | borg import\-tar \-\-timestamp=$T repo2::$A \-"
+  echo "borg \-r repo1 export\-tar \-\-tar\-format=BORG $A \- | borg \-r repo2 import\-tar \-\-timestamp=$T $A \-"
 done
 .ft P
 .fi
diff --git a/docs/man/borg-info.1 b/docs/man/borg-info.1
index dfc2487d5..fccf6ee69 100644
--- a/docs/man/borg-info.1
+++ b/docs/man/borg-info.1
@@ -1,8 +1,5 @@
 .\" Man page generated from reStructuredText.
 .
-.TH BORG-INFO 1 "2022-04-14" "" "borg backup tool"
-.SH NAME
-borg-info \- Show archive details such as disk space used
 .
 .nr rst2man-indent-level 0
 .
@@ -30,12 +27,15 @@ level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .in \\n[rst2man-indent\\n[rst2man-indent-level]]u
 ..
+.TH "BORG-INFO" 1 "2022-06-25" "" "borg backup tool"
+.SH NAME
+borg-info \- Show archive details such as disk space used
 .SH SYNOPSIS
 .sp
-borg [common options] info [options] [REPOSITORY_OR_ARCHIVE]
+borg [common options] info [options]
 .SH DESCRIPTION
 .sp
-This command displays detailed information about the specified archive or repository.
+This command displays detailed information about the specified archive.
 .sp
 Please note that the deduplicated sizes of the individual archives do not add
 up to the deduplicated size of the repository ("all archives"), because the two
@@ -53,16 +53,10 @@ This is shown as \fIutilization of maximum supported archive size\fP\&.
 .SH OPTIONS
 .sp
 See \fIborg\-common(1)\fP for common options of Borg commands.
-.SS arguments
-.INDENT 0.0
-.TP
-.B REPOSITORY_OR_ARCHIVE
-repository or archive to display information about
-.UNINDENT
 .SS optional arguments
 .INDENT 0.0
 .TP
-.B \-\-json
+.B  \-\-json
 format output as JSON
 .UNINDENT
 .SS Archive filters
@@ -89,58 +83,20 @@ consider last N archives after other filters were applied
 .sp
 .nf
 .ft C
-$ borg info /path/to/repo::2017\-06\-29T11:00\-srv
-Archive name: 2017\-06\-29T11:00\-srv
-Archive fingerprint: b2f1beac2bd553b34e06358afa45a3c1689320d39163890c5bbbd49125f00fe5
+$ borg info Tuesday2022\-06\-25T20:51:39
+Archive name: Tuesday2022\-06\-25T20:51:39
+Archive fingerprint: f7dea0788dfc026cc2be1c0f5b94beb4e4084eb3402fc40c38d8719b1bf2d943
 Comment:
-Hostname: myhostname
-Username: root
-Time (start): Thu, 2017\-06\-29 11:03:07
-Time (end): Thu, 2017\-06\-29 11:03:13
-Duration: 5.66 seconds
-Number of files: 17037
-Command line: /usr/sbin/borg create /path/to/repo::2017\-06\-29T11:00\-srv /srv
-Utilization of max. archive size: 0%
-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-
-                       Original size      Compressed size    Deduplicated size
-This archive:               12.53 GB             12.49 GB              1.62 kB
-All archives:              121.82 TB            112.41 TB            215.42 GB
-
-                       Unique chunks         Total chunks
-Chunk index:                 1015213            626934122
-
-$ borg info /path/to/repo \-\-last 1
-Archive name: 2017\-06\-29T11:00\-srv
-Archive fingerprint: b2f1beac2bd553b34e06358afa45a3c1689320d39163890c5bbbd49125f00fe5
-Comment:
-Hostname: myhostname
-Username: root
-Time (start): Thu, 2017\-06\-29 11:03:07
-Time (end): Thu, 2017\-06\-29 11:03:13
-Duration: 5.66 seconds
-Number of files: 17037
-Command line: /usr/sbin/borg create /path/to/repo::2017\-06\-29T11:00\-srv /srv
-Utilization of max. archive size: 0%
-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-
-                       Original size      Compressed size    Deduplicated size
-This archive:               12.53 GB             12.49 GB              1.62 kB
-All archives:              121.82 TB            112.41 TB            215.42 GB
-
-                       Unique chunks         Total chunks
-Chunk index:                 1015213            626934122
-
-$ borg info /path/to/repo
-Repository ID: d857ce5788c51272c61535062e89eac4e8ef5a884ffbe976e0af9d8765dedfa5
-Location: /path/to/repo
-Encrypted: Yes (repokey)
-Cache: /root/.cache/borg/d857ce5788c51272c61535062e89eac4e8ef5a884ffbe976e0af9d8765dedfa5
-Security dir: /root/.config/borg/security/d857ce5788c51272c61535062e89eac4e8ef5a884ffbe976e0af9d8765dedfa5
-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-
-                       Original size      Compressed size    Deduplicated size
-All archives:              121.82 TB            112.41 TB            215.42 GB
-
-                       Unique chunks         Total chunks
-Chunk index:                 1015213            626934122
+Hostname: mba2020
+Username: tw
+Time (start): Sat, 2022\-06\-25 20:51:40
+Time (end): Sat, 2022\-06\-25 20:51:40
+Duration: 0.03 seconds
+Command line: /Users/tw/w/borg\-env/bin/borg \-r path/to/repo create \-\-stats \(aqTuesday{now}\(aq src \-\-progress
+Utilization of maximum supported archive size: 0%
+Number of files: 244
+Original size: 13.80 MB
+Deduplicated size: 531 B
 .ft P
 .fi
 .UNINDENT
diff --git a/docs/man/borg-key-change-algorithm.1 b/docs/man/borg-key-change-algorithm.1
index efcb6374b..6308a926b 100644
--- a/docs/man/borg-key-change-algorithm.1
+++ b/docs/man/borg-key-change-algorithm.1
@@ -1,8 +1,5 @@
 .\" Man page generated from reStructuredText.
 .
-.TH BORG-KEY-CHANGE-ALGORITHM 1 "2022-04-14" "" "borg backup tool"
-.SH NAME
-borg-key-change-algorithm \- Change repository key algorithm
 .
 .nr rst2man-indent-level 0
 .
@@ -30,9 +27,12 @@ level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .in \\n[rst2man-indent\\n[rst2man-indent-level]]u
 ..
+.TH "BORG-KEY-CHANGE-ALGORITHM" 1 "2022-06-25" "" "borg backup tool"
+.SH NAME
+borg-key-change-algorithm \- Change repository key algorithm
 .SH SYNOPSIS
 .sp
-borg [common options] key change\-algorithm [options] [REPOSITORY] ALGORITHM
+borg [common options] key change\-algorithm [options] ALGORITHM
 .SH DESCRIPTION
 .sp
 Change the algorithm we use to encrypt and authenticate the borg key.
@@ -77,8 +77,6 @@ borg key change\-algorithm /path/to/repo pbkdf2
 .sp
 See \fIborg\-common(1)\fP for common options of Borg commands.
 .SS arguments
-.sp
-REPOSITORY
 .INDENT 0.0
 .TP
 .B ALGORITHM
diff --git a/docs/man/borg-key-change-location.1 b/docs/man/borg-key-change-location.1
index f40e83416..a0b626420 100644
--- a/docs/man/borg-key-change-location.1
+++ b/docs/man/borg-key-change-location.1
@@ -1,8 +1,5 @@
 .\" Man page generated from reStructuredText.
 .
-.TH BORG-KEY-CHANGE-LOCATION 1 "2022-04-14" "" "borg backup tool"
-.SH NAME
-borg-key-change-location \- Change repository key location
 .
 .nr rst2man-indent-level 0
 .
@@ -30,26 +27,30 @@ level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .in \\n[rst2man-indent\\n[rst2man-indent-level]]u
 ..
+.TH "BORG-KEY-CHANGE-LOCATION" 1 "2022-06-25" "" "borg backup tool"
+.SH NAME
+borg-key-change-location \- Change repository key location
 .SH SYNOPSIS
 .sp
-borg [common options] key change\-location [options] [REPOSITORY] KEY_LOCATION
+borg [common options] key change\-location [options] KEY_LOCATION
 .SH DESCRIPTION
 .sp
 Change the location of a borg key. The key can be stored at different locations:
-.sp
-keyfile: locally, usually in the home directory
-repokey: inside the repo (in the repo config)
 .INDENT 0.0
-.TP
-.B Note: this command does NOT change the crypto algorithms, just the key location,
-thus you must ONLY give the key location (keyfile or repokey).
+.IP \(bu 2
+keyfile: locally, usually in the home directory
+.IP \(bu 2
+repokey: inside the repo (in the repo config)
 .UNINDENT
+.sp
+Please note:
+.sp
+This command does NOT change the crypto algorithms, just the key location,
+thus you must ONLY give the key location (keyfile or repokey).
 .SH OPTIONS
 .sp
 See \fIborg\-common(1)\fP for common options of Borg commands.
 .SS arguments
-.sp
-REPOSITORY
 .INDENT 0.0
 .TP
 .B KEY_LOCATION
@@ -58,7 +59,7 @@ select key location
 .SS optional arguments
 .INDENT 0.0
 .TP
-.B \-\-keep
+.B  \-\-keep
 keep the key also at the current location (default: remove it)
 .UNINDENT
 .SH SEE ALSO
diff --git a/docs/man/borg-key-change-passphrase.1 b/docs/man/borg-key-change-passphrase.1
index 9567c6ebb..1a3b169a9 100644
--- a/docs/man/borg-key-change-passphrase.1
+++ b/docs/man/borg-key-change-passphrase.1
@@ -1,8 +1,5 @@
 .\" Man page generated from reStructuredText.
 .
-.TH BORG-KEY-CHANGE-PASSPHRASE 1 "2022-04-14" "" "borg backup tool"
-.SH NAME
-borg-key-change-passphrase \- Change repository key file passphrase
 .
 .nr rst2man-indent-level 0
 .
@@ -30,9 +27,12 @@ level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .in \\n[rst2man-indent\\n[rst2man-indent-level]]u
 ..
+.TH "BORG-KEY-CHANGE-PASSPHRASE" 1 "2022-06-25" "" "borg backup tool"
+.SH NAME
+borg-key-change-passphrase \- Change repository key file passphrase
 .SH SYNOPSIS
 .sp
-borg [common options] key change\-passphrase [options] [REPOSITORY]
+borg [common options] key change\-passphrase [options]
 .SH DESCRIPTION
 .sp
 The key files used for repository encryption are optionally passphrase
@@ -45,9 +45,6 @@ does not protect future (nor past) backups to the same repository.
 .SH OPTIONS
 .sp
 See \fIborg\-common(1)\fP for common options of Borg commands.
-.SS arguments
-.sp
-REPOSITORY
 .SH EXAMPLES
 .INDENT 0.0
 .INDENT 3.5
@@ -55,7 +52,7 @@ REPOSITORY
 .nf
 .ft C
 # Create a key file protected repository
-$ borg init \-\-encryption=keyfile \-v /path/to/repo
+$ borg rcreate \-\-encryption=keyfile \-v
 Initializing repository at "/path/to/repo"
 Enter new passphrase:
 Enter same passphrase again:
@@ -67,7 +64,7 @@ Archives: 0, w/ cached Idx: 0, w/ outdated Idx: 0, w/o cached Idx: 0.
 Done.
 
 # Change key file passphrase
-$ borg key change\-passphrase \-v /path/to/repo
+$ borg key change\-passphrase \-v
 Enter passphrase for key /root/.config/borg/keys/mnt_backup:
 Enter new passphrase:
 Enter same passphrase again:
@@ -77,7 +74,7 @@ Key updated
 # Import a previously\-exported key into the specified
 # key file (creating or overwriting the output key)
 # (keyfile repositories only)
-$ BORG_KEY_FILE=/path/to/output\-key borg key import /path/to/repo /path/to/exported
+$ BORG_KEY_FILE=/path/to/output\-key borg key import /path/to/exported
 .ft P
 .fi
 .UNINDENT
@@ -89,9 +86,9 @@ Fully automated using environment variables:
 .sp
 .nf
 .ft C
-$ BORG_NEW_PASSPHRASE=old borg init \-e=repokey repo
+$ BORG_NEW_PASSPHRASE=old borg rcreate \-e=repokey
 # now "old" is the current passphrase.
-$ BORG_PASSPHRASE=old BORG_NEW_PASSPHRASE=new borg key change\-passphrase repo
+$ BORG_PASSPHRASE=old BORG_NEW_PASSPHRASE=new borg key change\-passphrase
 # now "new" is the current passphrase.
 .ft P
 .fi
diff --git a/docs/man/borg-key-export.1 b/docs/man/borg-key-export.1
index 1202f32a3..0405d58f3 100644
--- a/docs/man/borg-key-export.1
+++ b/docs/man/borg-key-export.1
@@ -1,8 +1,5 @@
 .\" Man page generated from reStructuredText.
 .
-.TH BORG-KEY-EXPORT 1 "2022-04-14" "" "borg backup tool"
-.SH NAME
-borg-key-export \- Export the repository key for backup
 .
 .nr rst2man-indent-level 0
 .
@@ -30,9 +27,12 @@ level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .in \\n[rst2man-indent\\n[rst2man-indent-level]]u
 ..
+.TH "BORG-KEY-EXPORT" 1 "2022-06-25" "" "borg backup tool"
+.SH NAME
+borg-key-export \- Export the repository key for backup
 .SH SYNOPSIS
 .sp
-borg [common options] key export [options] [REPOSITORY] [PATH]
+borg [common options] key export [options] [PATH]
 .SH DESCRIPTION
 .sp
 If repository encryption is used, the repository is inaccessible
@@ -78,8 +78,6 @@ borg key export \-\-qr\-html /path/to/repo encrypted\-key\-backup.html
 .sp
 See \fIborg\-common(1)\fP for common options of Borg commands.
 .SS arguments
-.sp
-REPOSITORY
 .INDENT 0.0
 .TP
 .B PATH
@@ -88,10 +86,10 @@ where to store the backup
 .SS optional arguments
 .INDENT 0.0
 .TP
-.B \-\-paper
+.B  \-\-paper
 Create an export suitable for printing and later type\-in
 .TP
-.B \-\-qr\-html
+.B  \-\-qr\-html
 Create an html file suitable for printing and later type\-in or qr scan
 .UNINDENT
 .SH SEE ALSO
diff --git a/docs/man/borg-key-import.1 b/docs/man/borg-key-import.1
index e2a7acd25..cb466d963 100644
--- a/docs/man/borg-key-import.1
+++ b/docs/man/borg-key-import.1
@@ -1,8 +1,5 @@
 .\" Man page generated from reStructuredText.
 .
-.TH BORG-KEY-IMPORT 1 "2022-04-14" "" "borg backup tool"
-.SH NAME
-borg-key-import \- Import the repository key from backup
 .
 .nr rst2man-indent-level 0
 .
@@ -30,9 +27,12 @@ level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .in \\n[rst2man-indent\\n[rst2man-indent-level]]u
 ..
+.TH "BORG-KEY-IMPORT" 1 "2022-06-25" "" "borg backup tool"
+.SH NAME
+borg-key-import \- Import the repository key from backup
 .SH SYNOPSIS
 .sp
-borg [common options] key import [options] [REPOSITORY] [PATH]
+borg [common options] key import [options] [PATH]
 .SH DESCRIPTION
 .sp
 This command restores a key previously backed up with the export command.
@@ -53,8 +53,6 @@ key import\fP creates a new key file in \fB$BORG_KEYS_DIR\fP\&.
 .sp
 See \fIborg\-common(1)\fP for common options of Borg commands.
 .SS arguments
-.sp
-REPOSITORY
 .INDENT 0.0
 .TP
 .B PATH
@@ -63,7 +61,7 @@ path to the backup (\(aq\-\(aq to read from stdin)
 .SS optional arguments
 .INDENT 0.0
 .TP
-.B \-\-paper
+.B  \-\-paper
 interactively import from a backup done with \fB\-\-paper\fP
 .UNINDENT
 .SH SEE ALSO
diff --git a/docs/man/borg-key.1 b/docs/man/borg-key.1
index 5cb2a6b40..82780ff82 100644
--- a/docs/man/borg-key.1
+++ b/docs/man/borg-key.1
@@ -1,8 +1,5 @@
 .\" Man page generated from reStructuredText.
 .
-.TH BORG-KEY 1 "2022-04-14" "" "borg backup tool"
-.SH NAME
-borg-key \- Manage a keyfile or repokey of a repository
 .
 .nr rst2man-indent-level 0
 .
@@ -30,6 +27,9 @@ level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .in \\n[rst2man-indent\\n[rst2man-indent-level]]u
 ..
+.TH "BORG-KEY" 1 "2022-06-25" "" "borg backup tool"
+.SH NAME
+borg-key \- Manage a keyfile or repokey of a repository
 .SH SYNOPSIS
 .nf
 borg [common options] key export ...
diff --git a/docs/man/borg-list.1 b/docs/man/borg-list.1
index d34fdf54e..6b366005d 100644
--- a/docs/man/borg-list.1
+++ b/docs/man/borg-list.1
@@ -1,8 +1,5 @@
 .\" Man page generated from reStructuredText.
 .
-.TH BORG-LIST 1 "2022-04-14" "" "borg backup tool"
-.SH NAME
-borg-list \- List archive or repository contents
 .
 .nr rst2man-indent-level 0
 .
@@ -30,12 +27,15 @@ level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .in \\n[rst2man-indent\\n[rst2man-indent-level]]u
 ..
+.TH "BORG-LIST" 1 "2022-06-25" "" "borg backup tool"
+.SH NAME
+borg-list \- List archive contents
 .SH SYNOPSIS
 .sp
-borg [common options] list [options] [REPOSITORY_OR_ARCHIVE] [PATH...]
+borg [common options] list [options] NAME [PATH...]
 .SH DESCRIPTION
 .sp
-This command lists the contents of a repository or an archive.
+This command lists the contents of an archive.
 .sp
 For more help on include/exclude patterns, see the \fIborg_patterns\fP command output.
 .SH OPTIONS
@@ -44,8 +44,8 @@ See \fIborg\-common(1)\fP for common options of Borg commands.
 .SS arguments
 .INDENT 0.0
 .TP
-.B REPOSITORY_OR_ARCHIVE
-repository or archive to list contents of
+.B NAME
+specify the archive name
 .TP
 .B PATH
 paths to list; patterns are supported
@@ -53,38 +53,14 @@ paths to list; patterns are supported
 .SS optional arguments
 .INDENT 0.0
 .TP
-.B \-\-consider\-checkpoints
-Show checkpoint archives in the repository contents list (default: hidden).
-.TP
-.B \-\-short
+.B  \-\-short
 only print file/directory names, nothing else
 .TP
 .BI \-\-format \ FORMAT
-specify format for file or archive listing (default for files: "{mode} {user:6} {group:6} {size:8} {mtime} {path}{extra}{NL}"; for archives: "{archive:<36} {time} [{id}]{NL}")
+specify format for file listing (default: "{mode} {user:6} {group:6} {size:8} {mtime} {path}{extra}{NL}")
 .TP
-.B \-\-json
-Only valid for listing repository contents. Format output as JSON. The form of \fB\-\-format\fP is ignored, but keys used in it are added to the JSON output. Some keys are always present. Note: JSON can only represent text. A "barchive" key is therefore not available.
-.TP
-.B \-\-json\-lines
-Only valid for listing archive contents. Format output as JSON Lines. The form of \fB\-\-format\fP is ignored, but keys used in it are added to the JSON output. Some keys are always present. Note: JSON can only represent text. A "bpath" key is therefore not available.
-.UNINDENT
-.SS Archive filters
-.INDENT 0.0
-.TP
-.BI \-P \ PREFIX\fR,\fB \ \-\-prefix \ PREFIX
-only consider archive names starting with this prefix.
-.TP
-.BI \-a \ GLOB\fR,\fB \ \-\-glob\-archives \ GLOB
-only consider archive names matching the glob. sh: rules apply, see "borg help patterns". \fB\-\-prefix\fP and \fB\-\-glob\-archives\fP are mutually exclusive.
-.TP
-.BI \-\-sort\-by \ KEYS
-Comma\-separated list of sorting keys; valid keys are: timestamp, name, id; default is: timestamp
-.TP
-.BI \-\-first \ N
-consider first N archives after other filters were applied
-.TP
-.BI \-\-last \ N
-consider last N archives after other filters were applied
+.B  \-\-json\-lines
+Format output as JSON Lines. The form of \fB\-\-format\fP is ignored, but keys used in it are added to the JSON output. Some keys are always present. Note: JSON can only represent text. A "bpath" key is therefore not available.
 .UNINDENT
 .SS Exclusion options
 .INDENT 0.0
@@ -107,14 +83,7 @@ read include/exclude patterns from PATTERNFILE, one per line
 .sp
 .nf
 .ft C
-$ borg list /path/to/repo
-Monday                               Mon, 2016\-02\-15 19:15:11
-repo                                 Mon, 2016\-02\-15 19:26:54
-root\-2016\-02\-15                      Mon, 2016\-02\-15 19:36:29
-newname                              Mon, 2016\-02\-15 19:50:19
-\&...
-
-$ borg list /path/to/repo::root\-2016\-02\-15
+$ borg list root\-2016\-02\-15
 drwxr\-xr\-x root   root          0 Mon, 2016\-02\-15 17:44:27 .
 drwxrwxr\-x root   root          0 Mon, 2016\-02\-15 19:04:49 bin
 \-rwxr\-xr\-x root   root    1029624 Thu, 2014\-11\-13 00:08:51 bin/bash
@@ -122,14 +91,14 @@ lrwxrwxrwx root   root          0 Fri, 2015\-03\-27 20:24:26 bin/bzcmp \-> bzdif
 \-rwxr\-xr\-x root   root       2140 Fri, 2015\-03\-27 20:24:22 bin/bzdiff
 \&...
 
-$ borg list /path/to/repo::root\-2016\-02\-15 \-\-pattern "\- bin/ba*"
+$ borg list root\-2016\-02\-15 \-\-pattern "\- bin/ba*"
 drwxr\-xr\-x root   root          0 Mon, 2016\-02\-15 17:44:27 .
 drwxrwxr\-x root   root          0 Mon, 2016\-02\-15 19:04:49 bin
 lrwxrwxrwx root   root          0 Fri, 2015\-03\-27 20:24:26 bin/bzcmp \-> bzdiff
 \-rwxr\-xr\-x root   root       2140 Fri, 2015\-03\-27 20:24:22 bin/bzdiff
 \&...
 
-$ borg list /path/to/repo::archiveA \-\-format="{mode} {user:6} {group:6} {size:8d} {isomtime} {path}{extra}{NEWLINE}"
+$ borg list archiveA \-\-format="{mode} {user:6} {group:6} {size:8d} {isomtime} {path}{extra}{NEWLINE}"
 drwxrwxr\-x user   user          0 Sun, 2015\-02\-01 11:00:00 .
 drwxrwxr\-x user   user          0 Sun, 2015\-02\-01 11:00:00 code
 drwxrwxr\-x user   user          0 Sun, 2015\-02\-01 11:00:00 code/myproject
@@ -137,11 +106,11 @@ drwxrwxr\-x user   user          0 Sun, 2015\-02\-01 11:00:00 code/myproject
 \-rw\-rw\-r\-\- user   user    1416192 Sun, 2015\-02\-01 11:00:00 code/myproject/file.text
 \&...
 
-$ borg list /path/to/repo/::archiveA \-\-pattern \(aqre:\e.ext$\(aq
+$ borg list archiveA \-\-pattern \(aqre:\e.ext$\(aq
 \-rw\-rw\-r\-\- user   user    1416192 Sun, 2015\-02\-01 11:00:00 code/myproject/file.ext
 \&...
 
-$ borg list /path/to/repo/::archiveA \-\-pattern \(aqre:.ext$\(aq
+$ borg list archiveA \-\-pattern \(aqre:.ext$\(aq
 \-rw\-rw\-r\-\- user   user    1416192 Sun, 2015\-02\-01 11:00:00 code/myproject/file.ext
 \-rw\-rw\-r\-\- user   user    1416192 Sun, 2015\-02\-01 11:00:00 code/myproject/file.text
 \&...
@@ -160,23 +129,13 @@ Examples:
 .sp
 .nf
 .ft C
-$ borg list \-\-format \(aq{archive}{NL}\(aq /path/to/repo
-ArchiveFoo
-ArchiveBar
-\&...
-
-# {VAR:NUMBER} \- pad to NUMBER columns.
-# Strings are left\-aligned, numbers are right\-aligned.
-# Note: time columns except \(ga\(gaisomtime\(ga\(ga, \(ga\(gaisoctime\(ga\(ga and \(ga\(gaisoatime\(ga\(ga cannot be padded.
-$ borg list \-\-format \(aq{archive:36} {time} [{id}]{NL}\(aq /path/to/repo
-ArchiveFoo                           Thu, 2021\-12\-09 10:22:28 [0b8e9a312bef3f2f6e2d0fc110c196827786c15eba0188738e81697a7fa3b274]
-$ borg list \-\-format \(aq{mode} {user:6} {group:6} {size:8} {mtime} {path}{extra}{NL}\(aq /path/to/repo::ArchiveFoo
+$ borg list \-\-format \(aq{mode} {user:6} {group:6} {size:8} {mtime} {path}{extra}{NL}\(aq ArchiveFoo
 \-rw\-rw\-r\-\- user   user       1024 Thu, 2021\-12\-09 10:22:17 file\-foo
 \&...
 
 # {VAR:<NUMBER} \- pad to NUMBER columns left\-aligned.
 # {VAR:>NUMBER} \- pad to NUMBER columns right\-aligned.
-$ borg list \-\-format \(aq{mode} {user:>6} {group:>6} {size:<8} {mtime} {path}{extra}{NL}\(aq /path/to/repo::ArchiveFoo
+$ borg list \-\-format \(aq{mode} {user:>6} {group:>6} {size:<8} {mtime} {path}{extra}{NL}\(aq ArchiveFoo
 \-rw\-rw\-r\-\-   user   user 1024     Thu, 2021\-12\-09 10:22:17 file\-foo
 \&...
 .ft P
@@ -185,50 +144,13 @@ $ borg list \-\-format \(aq{mode} {user:>6} {group:>6} {size:<8} {mtime} {path}{
 .UNINDENT
 .sp
 The following keys are always available:
-.INDENT 0.0
-.IP \(bu 2
-NEWLINE: OS dependent line separator
-.IP \(bu 2
-NL: alias of NEWLINE
-.IP \(bu 2
-NUL: NUL character for creating print0 / xargs \-0 like output, see barchive and bpath keys below
-.IP \(bu 2
-SPACE
-.IP \(bu 2
-TAB
-.IP \(bu 2
-CR
-.IP \(bu 2
-LF
-.UNINDENT
-.sp
-Keys available only when listing archives in a repository:
-.INDENT 0.0
-.IP \(bu 2
-archive: archive name interpreted as text (might be missing non\-text characters, see barchive)
-.IP \(bu 2
-name: alias of "archive"
-.IP \(bu 2
-barchive: verbatim archive name, can contain any character except NUL
-.IP \(bu 2
-comment: archive comment interpreted as text (might be missing non\-text characters, see bcomment)
-.IP \(bu 2
-bcomment: verbatim archive comment, can contain any character except NUL
-.IP \(bu 2
-id: internal ID of the archive
-.IP \(bu 2
-start: time (start) of creation of the archive
-.IP \(bu 2
-time: alias of "start"
-.IP \(bu 2
-end: time (end) of creation of the archive
-.IP \(bu 2
-command_line: command line which was used to create the archive
-.IP \(bu 2
-hostname: hostname of host on which this archive was created
-.IP \(bu 2
-username: username of user who created this archive
-.UNINDENT
+\- NEWLINE: OS dependent line separator
+\- NL: alias of NEWLINE
+\- NUL: NUL character for creating print0 / xargs \-0 like output, see barchive and bpath keys below
+\- SPACE
+\- TAB
+\- CR
+\- LF
 .sp
 Keys available only when listing files in an archive:
 .INDENT 0.0
@@ -249,20 +171,18 @@ path: path interpreted as text (might be missing non\-text characters, see bpath
 .IP \(bu 2
 bpath: verbatim POSIX path, can contain any character except NUL
 .IP \(bu 2
-source: link target for links (identical to linktarget)
+source: link target for symlinks (identical to linktarget)
 .IP \(bu 2
 linktarget
 .IP \(bu 2
+hlid: hard link identity (same if hardlinking same fs object)
+.IP \(bu 2
 flags
 .IP \(bu 2
 size
 .IP \(bu 2
-csize: compressed size
-.IP \(bu 2
 dsize: deduplicated size
 .IP \(bu 2
-dcsize: deduplicated compressed size
-.IP \(bu 2
 num_chunks: number of chunks in this file
 .IP \(bu 2
 unique_chunks: number of unique chunks in this file
diff --git a/docs/man/borg-mount.1 b/docs/man/borg-mount.1
index 182c5411a..4ebbcf753 100644
--- a/docs/man/borg-mount.1
+++ b/docs/man/borg-mount.1
@@ -1,8 +1,5 @@
 .\" Man page generated from reStructuredText.
 .
-.TH BORG-MOUNT 1 "2022-04-14" "" "borg backup tool"
-.SH NAME
-borg-mount \- Mount archive or an entire repository as a FUSE filesystem
 .
 .nr rst2man-indent-level 0
 .
@@ -30,9 +27,12 @@ level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .in \\n[rst2man-indent\\n[rst2man-indent-level]]u
 ..
+.TH "BORG-MOUNT" 1 "2022-06-25" "" "borg backup tool"
+.SH NAME
+borg-mount \- Mount archive or an entire repository as a FUSE filesystem
 .SH SYNOPSIS
 .sp
-borg [common options] mount [options] REPOSITORY_OR_ARCHIVE MOUNTPOINT [PATH...]
+borg [common options] mount [options] MOUNTPOINT [PATH...]
 .SH DESCRIPTION
 .sp
 This command mounts an archive as a FUSE filesystem. This can be useful for
@@ -98,9 +98,6 @@ See \fIborg\-common(1)\fP for common options of Borg commands.
 .SS arguments
 .INDENT 0.0
 .TP
-.B REPOSITORY_OR_ARCHIVE
-repository or archive to mount
-.TP
 .B MOUNTPOINT
 where to mount filesystem
 .TP
@@ -110,19 +107,19 @@ paths to extract; patterns are supported
 .SS optional arguments
 .INDENT 0.0
 .TP
-.B \-\-consider\-checkpoints
+.B  \-\-consider\-checkpoints
 Show checkpoint archives in the repository contents list (default: hidden).
 .TP
-.B \-f\fP,\fB  \-\-foreground
+.B  \-f\fP,\fB  \-\-foreground
 stay in foreground, do not daemonize
 .TP
-.B \-o
+.B  \-o
 Extra mount options
 .TP
-.B \-\-numeric\-owner
+.B  \-\-numeric\-owner
 deprecated, use \fB\-\-numeric\-ids\fP instead
 .TP
-.B \-\-numeric\-ids
+.B  \-\-numeric\-ids
 use numeric user and group identifiers from archive(s)
 .UNINDENT
 .SS Archive filters
diff --git a/docs/man/borg-patterns.1 b/docs/man/borg-patterns.1
index 546cd9259..bcf2adf5c 100644
--- a/docs/man/borg-patterns.1
+++ b/docs/man/borg-patterns.1
@@ -1,8 +1,5 @@
 .\" Man page generated from reStructuredText.
 .
-.TH BORG-PATTERNS 1 "2022-04-14" "" "borg backup tool"
-.SH NAME
-borg-patterns \- Details regarding patterns
 .
 .nr rst2man-indent-level 0
 .
@@ -30,45 +27,47 @@ level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .in \\n[rst2man-indent\\n[rst2man-indent-level]]u
 ..
+.TH "BORG-PATTERNS" 1 "2022-06-25" "" "borg backup tool"
+.SH NAME
+borg-patterns \- Details regarding patterns
 .SH DESCRIPTION
 .sp
-The path/filenames used as input for the pattern matching start from the
-currently active recursion root. You usually give the recursion root(s)
-when invoking borg and these can be either relative or absolute paths.
+When specifying one or more file paths in a Borg command that supports
+patterns for the respective option or argument, you can apply the
+patterns described here to include only desired files and/or exclude
+unwanted ones. Patterns can be used
+.INDENT 0.0
+.IP \(bu 2
+for \fB\-\-exclude\fP option,
+.IP \(bu 2
+in the file given with \fB\-\-exclude\-from\fP option,
+.IP \(bu 2
+for \fB\-\-pattern\fP option,
+.IP \(bu 2
+in the file given with \fB\-\-patterns\-from\fP option and
+.IP \(bu 2
+for \fBPATH\fP arguments that explicitly support them.
+.UNINDENT
 .sp
-So, when you give \fIrelative/\fP as root, the paths going into the matcher
-will look like \fIrelative/.../file.ext\fP\&. When you give \fI/absolute/\fP as
-root, they will look like \fI/absolute/.../file.ext\fP\&.
+Borg always stores all file paths normalized and relative to the
+current recursion root. The recursion root is also named \fBPATH\fP in
+Borg commands like \fIborg create\fP that do a file discovery, so do not
+confuse the root with the \fBPATH\fP argument of e.g. \fIborg extract\fP\&.
 .sp
-File paths in Borg archives are always stored normalized and relative.
-This means that e.g. \fBborg create /path/to/repo ../some/path\fP will
-store all files as \fIsome/path/.../file.ext\fP and \fBborg create
-/path/to/repo /home/user\fP will store all files as
-\fIhome/user/.../file.ext\fP\&.
+Starting with Borg 1.2, paths that are matched against patterns always
+appear relative. If you give \fB/absolute/\fP as root, the paths going
+into the matcher will look relative like \fBabsolute/.../file.ext\fP\&.
+If you give \fB\&../some/path\fP as root, the paths will look like
+\fBsome/path/.../file.ext\fP\&.
 .sp
-A directory exclusion pattern can end either with or without a slash (\(aq/\(aq).
-If it ends with a slash, such as \fIsome/path/\fP, the directory will be
-included but not its content. If it does not end with a slash, such as
-\fIsome/path\fP, both the directory and content will be excluded.
-.sp
-File patterns support these styles: fnmatch, shell, regular expressions,
-path prefixes and path full\-matches. By default, fnmatch is used for
-\fB\-\-exclude\fP patterns and shell\-style is used for the \fB\-\-pattern\fP
-option. For commands that support patterns in their \fBPATH\fP argument
-like (\fBborg list\fP), the default pattern is path prefix.
-.sp
-Starting with Borg 1.2, for all but regular expression pattern matching
-styles, all paths are treated as relative, meaning that a leading path
-separator is removed after normalizing and before matching. This allows
-you to use absolute or relative patterns arbitrarily.
-.sp
-If followed by a colon (\(aq:\(aq) the first two characters of a pattern are
-used as a style selector. Explicit style selection is necessary when a
-non\-default style is desired or when the desired pattern starts with
-two alphanumeric characters followed by a colon (i.e. \fIaa:something/*\fP).
+File patterns support five different styles. If followed by a colon \(aq:\(aq,
+the first two characters of a pattern are used as a style selector.
+Explicit style selection is necessary if a non\-default style is desired
+or when the desired pattern starts with two alphanumeric characters
+followed by a colon (i.e. \fBaa:something/*\fP).
 .INDENT 0.0
 .TP
-.B \fI\%Fnmatch\fP, selector \fIfm:\fP
+.B \fI\%Fnmatch\fP, selector \fBfm:\fP
 This is the default style for \fB\-\-exclude\fP and \fB\-\-exclude\-from\fP\&.
 These patterns use a variant of shell pattern syntax, with \(aq*\(aq matching
 any number of characters, \(aq?\(aq matching any single character, \(aq[...]\(aq
@@ -76,7 +75,7 @@ matching any single character specified, including ranges, and \(aq[!...]\(aq
 matching any character not specified. For the purpose of these patterns,
 the path separator (backslash for Windows and \(aq/\(aq on other systems) is not
 treated specially. Wrap meta\-characters in brackets for a literal
-match (i.e. \fI[?]\fP to match the literal character \fI?\fP). For a path
+match (i.e. \fB[?]\fP to match the literal character \(aq?\(aq). For a path
 to match a pattern, the full path must match, or it must match
 from the start of the full path to just before a path separator. Except
 for the root path, paths will never end in the path separator when
@@ -84,33 +83,31 @@ matching is attempted.  Thus, if a given pattern ends in a path
 separator, a \(aq*\(aq is appended before matching is attempted. A leading
 path separator is always removed.
 .TP
-.B Shell\-style patterns, selector \fIsh:\fP
+.B Shell\-style patterns, selector \fBsh:\fP
 This is the default style for \fB\-\-pattern\fP and \fB\-\-patterns\-from\fP\&.
 Like fnmatch patterns these are similar to shell patterns. The difference
-is that the pattern may include \fI**/\fP for matching zero or more directory
-levels, \fI*\fP for matching zero or more arbitrary characters with the
+is that the pattern may include \fB**/\fP for matching zero or more directory
+levels, \fB*\fP for matching zero or more arbitrary characters with the
 exception of any path separator. A leading path separator is always removed.
 .TP
-.B Regular expressions, selector \fIre:\fP
-Regular expressions similar to those found in Perl are supported. Unlike
-shell patterns regular expressions are not required to match the full
+.B \fI\%Regular expressions\fP, selector \fBre:\fP
+Unlike shell patterns, regular expressions are not required to match the full
 path and any substring match is sufficient. It is strongly recommended to
 anchor patterns to the start (\(aq^\(aq), to the end (\(aq$\(aq) or both. Path
 separators (backslash for Windows and \(aq/\(aq on other systems) in paths are
-always normalized to a forward slash (\(aq/\(aq) before applying a pattern. The
-regular expression syntax is described in the \fI\%Python documentation for
-the re module\fP\&.
+always normalized to a forward slash \(aq/\(aq before applying a pattern.
 .TP
-.B Path prefix, selector \fIpp:\fP
+.B Path prefix, selector \fBpp:\fP
 This pattern style is useful to match whole sub\-directories. The pattern
-\fIpp:root/somedir\fP matches \fIroot/somedir\fP and everything therein. A leading
-path separator is always removed.
+\fBpp:root/somedir\fP matches \fBroot/somedir\fP and everything therein.
+A leading path separator is always removed.
 .TP
-.B Path full\-match, selector \fIpf:\fP
+.B Path full\-match, selector \fBpf:\fP
 This pattern style is (only) useful to match full paths.
 This is kind of a pseudo pattern as it can not have any variable or
-unspecified parts \- the full path must be given. \fIpf:root/file.ext\fP matches
-\fIroot/file.ext\fP only. A leading path separator is always removed.
+unspecified parts \- the full path must be given. \fBpf:root/file.ext\fP
+matches \fBroot/file.ext\fP only. A leading path separator is always
+removed.
 .sp
 Implementation note: this is implemented via very time\-efficient O(1)
 hashtable lookups (this means you can have huge amounts of such patterns
@@ -125,12 +122,12 @@ Same logic applies for exclude.
 \fBNOTE:\fP
 .INDENT 0.0
 .INDENT 3.5
-\fIre:\fP, \fIsh:\fP and \fIfm:\fP patterns are all implemented on top of the Python SRE
-engine. It is very easy to formulate patterns for each of these types which
-requires an inordinate amount of time to match paths. If untrusted users
-are able to supply patterns, ensure they cannot supply \fIre:\fP patterns.
-Further, ensure that \fIsh:\fP and \fIfm:\fP patterns only contain a handful of
-wildcards at most.
+\fBre:\fP, \fBsh:\fP and \fBfm:\fP patterns are all implemented on top of
+the Python SRE engine. It is very easy to formulate patterns for each
+of these types which requires an inordinate amount of time to match
+paths. If untrusted users are able to supply patterns, ensure they
+cannot supply \fBre:\fP patterns. Further, ensure that \fBsh:\fP and
+\fBfm:\fP patterns only contain a handful of wildcards at most.
 .UNINDENT
 .UNINDENT
 .sp
@@ -139,8 +136,8 @@ from within a shell, the patterns should be quoted to protect them from
 expansion.
 .sp
 The \fB\-\-exclude\-from\fP option permits loading exclusion patterns from a text
-file with one pattern per line. Lines empty or starting with the number sign
-(\(aq#\(aq) after removing whitespace on both ends are ignored. The optional style
+file with one pattern per line. Lines empty or starting with the hash sign
+\(aq#\(aq after removing whitespace on both ends are ignored. The optional style
 selector prefix is also supported for patterns loaded from a file. Due to
 whitespace removal, paths with whitespace at the beginning or end can only be
 excluded using regular expressions.
@@ -155,74 +152,101 @@ Examples:
 .nf
 .ft C
 # Exclude \(aq/home/user/file.o\(aq but not \(aq/home/user/file.odt\(aq:
-$ borg create \-e \(aq*.o\(aq backup /
+$ borg create \-e \(aq*.o\(aq archive /
 
 # Exclude \(aq/home/user/junk\(aq and \(aq/home/user/subdir/junk\(aq but
 # not \(aq/home/user/importantjunk\(aq or \(aq/etc/junk\(aq:
-$ borg create \-e \(aq/home/*/junk\(aq backup /
+$ borg create \-e \(aqhome/*/junk\(aq archive /
 
 # Exclude the contents of \(aq/home/user/cache\(aq but not the directory itself:
-$ borg create \-e home/user/cache/ backup /
+$ borg create \-e home/user/cache/ archive /
 
 # The file \(aq/home/user/cache/important\(aq is *not* backed up:
-$ borg create \-e /home/user/cache/ backup / /home/user/cache/important
+$ borg create \-e home/user/cache/ archive / /home/user/cache/important
 
 # The contents of directories in \(aq/home\(aq are not backed up when their name
 # ends in \(aq.tmp\(aq
-$ borg create \-\-exclude \(aqre:^/home/[^/]+\e.tmp/\(aq backup /
+$ borg create \-\-exclude \(aqre:^home/[^/]+\e.tmp/\(aq archive /
 
 # Load exclusions from file
 $ cat >exclude.txt <<EOF
 # Comment line
-/home/*/junk
+home/*/junk
 *.tmp
 fm:aa:something/*
-re:^/home/[^/]+\e.tmp/
-sh:/home/*/.thumbnails
+re:^home/[^/]+\e.tmp/
+sh:home/*/.thumbnails
 # Example with spaces, no need to escape as it is processed by borg
 some file with spaces.txt
 EOF
-$ borg create \-\-exclude\-from exclude.txt backup /
+$ borg create \-\-exclude\-from exclude.txt archive /
 .ft P
 .fi
 .UNINDENT
 .UNINDENT
 .sp
-A more general and easier to use way to define filename matching patterns exists
-with the \fB\-\-pattern\fP and \fB\-\-patterns\-from\fP options. Using these, you may
-specify the backup roots (starting points) and patterns for inclusion/exclusion.
-A root path starts with the prefix \fIR\fP, followed by a path (a plain path, not a
-file pattern). An include rule starts with the prefix +, an exclude rule starts
-with the prefix \-, an exclude\-norecurse rule starts with !, all followed by a pattern.
+A more general and easier to use way to define filename matching patterns
+exists with the \fB\-\-pattern\fP and \fB\-\-patterns\-from\fP options. Using
+these, you may specify the backup roots, default pattern styles and
+patterns for inclusion and exclusion.
+.INDENT 0.0
+.TP
+.B Root path prefix \fBR\fP
+A recursion root path starts with the prefix \fBR\fP, followed by a path
+(a plain path, not a file pattern). Use this prefix to have the root
+paths in the patterns file rather than as command line arguments.
+.TP
+.B Pattern style prefix \fBP\fP
+To change the default pattern style, use the \fBP\fP prefix, followed by
+the pattern style abbreviation (\fBfm\fP, \fBpf\fP, \fBpp\fP, \fBre\fP, \fBsh\fP).
+All patterns following this line will use this style until another style
+is specified.
+.TP
+.B Exclude pattern prefix \fB\-\fP
+Use the prefix \fB\-\fP, followed by a pattern, to define an exclusion.
+This has the same effect as the \fB\-\-exclude\fP option.
+.TP
+.B Exclude no\-recurse pattern prefix \fB!\fP
+Use the prefix \fB!\fP, followed by a pattern, to define an exclusion
+that does not recurse into subdirectories. This saves time, but
+prevents include patterns to match any files in subdirectories.
+.TP
+.B Include pattern prefix \fB+\fP
+Use the prefix \fB+\fP, followed by a pattern, to define inclusions.
+This is useful to include paths that are covered in an exclude
+pattern and would otherwise not be backed up.
+.UNINDENT
+.sp
+The first matching pattern is used, so if an include pattern matches
+before an exclude pattern, the file is backed up. Note that a no\-recurse
+exclude stops examination of subdirectories so that potential includes
+will not match \- use normal exludes for such use cases.
+.sp
+\fBTip: You can easily test your patterns with \-\-dry\-run and  \-\-list\fP:
+.INDENT 0.0
+.INDENT 3.5
+.sp
+.nf
+.ft C
+$ borg create \-\-dry\-run \-\-list \-\-patterns\-from patterns.txt archive
+.ft P
+.fi
+.UNINDENT
+.UNINDENT
+.sp
+This will list the considered files one per line, prefixed with a
+character that indicates the action (e.g. \(aqx\(aq for excluding, see
+\fBItem flags\fP in \fIborg create\fP usage docs).
 .sp
 \fBNOTE:\fP
 .INDENT 0.0
 .INDENT 3.5
-Via \fB\-\-pattern\fP or \fB\-\-patterns\-from\fP you can define BOTH inclusion and exclusion
-of files using pattern prefixes \fB+\fP and \fB\-\fP\&. With \fB\-\-exclude\fP and
-\fB\-\-exclude\-from\fP ONLY excludes are defined.
+It\(aqs possible that a sub\-directory/file is matched while parent
+directories are not. In that case, parent directories are not backed
+up and thus their user, group, permission, etc. cannot be restored.
 .UNINDENT
 .UNINDENT
 .sp
-Inclusion patterns are useful to include paths that are contained in an excluded
-path. The first matching pattern is used so if an include pattern matches before
-an exclude pattern, the file is backed up. If an exclude\-norecurse pattern matches
-a directory, it won\(aqt recurse into it and won\(aqt discover any potential matches for
-include rules below that directory.
-.sp
-\fBNOTE:\fP
-.INDENT 0.0
-.INDENT 3.5
-It\(aqs possible that a sub\-directory/file is matched while parent directories are not.
-In that case, parent directories are not backed up thus their user, group, permission,
-etc. can not be restored.
-.UNINDENT
-.UNINDENT
-.sp
-Note that the default pattern style for \fB\-\-pattern\fP and \fB\-\-patterns\-from\fP is
-shell style (\fIsh:\fP), so those patterns behave similar to rsync include/exclude
-patterns. The pattern style can be set via the \fIP\fP prefix.
-.sp
 Patterns (\fB\-\-pattern\fP) and excludes (\fB\-\-exclude\fP) from the command line are
 considered first (in the order of appearance). Then patterns from \fB\-\-patterns\-from\fP
 are added. Exclusion patterns from \fB\-\-exclude\-from\fP files are appended last.
@@ -235,10 +259,16 @@ Examples:
 .ft C
 # backup pics, but not the ones from 2018, except the good ones:
 # note: using = is essential to avoid cmdline argument parsing issues.
-borg create \-\-pattern=+pics/2018/good \-\-pattern=\-pics/2018 repo::arch pics
+borg create \-\-pattern=+pics/2018/good \-\-pattern=\-pics/2018 archive pics
 
-# use a file with patterns:
-borg create \-\-patterns\-from patterns.lst repo::arch
+# backup only JPG/JPEG files (case insensitive) in all home directories:
+borg create \-\-pattern \(aq+ re:\e.jpe?g(?i)$\(aq archive /home
+
+# backup homes, but exclude big downloads (like .ISO files) or hidden files:
+borg create \-\-exclude \(aqre:\e.iso(?i)$\(aq \-\-exclude \(aqsh:home/**/.*\(aq archive /home
+
+# use a file with patterns (recursion root \(aq/\(aq via command line):
+borg create \-\-patterns\-from patterns.lst archive /
 .ft P
 .fi
 .UNINDENT
@@ -250,22 +280,17 @@ The patterns.lst file could look like that:
 .sp
 .nf
 .ft C
-# "sh:" pattern style is the default, so the following line is not needed:
-P sh
-R /
-# can be rebuild
-\- /home/*/.cache
-# they\(aqre downloads for a reason
-\- /home/*/Downloads
-# susan is a nice person
+# "sh:" pattern style is the default
+# exclude caches
+\- home/*/.cache
 # include susans home
-+ /home/susan
++ home/susan
 # also back up this exact file
-+ pf:/home/bobby/specialfile.txt
++ pf:home/bobby/specialfile.txt
 # don\(aqt backup the other home directories
-\- /home/*
-# don\(aqt even look in /proc
-! /proc
+\- home/*
+# don\(aqt even look in /dev, /proc, /run, /sys, /tmp (note: would exclude files like /device, too)
+! re:^(dev|proc|run|sys|tmp)
 .ft P
 .fi
 .UNINDENT
@@ -278,14 +303,14 @@ You can specify recursion roots either on the command line or in a patternfile:
 .nf
 .ft C
 # these two commands do the same thing
-borg create \-\-exclude /home/bobby/junk repo::arch /home/bobby /home/susan
-borg create \-\-patterns\-from patternfile.lst repo::arch
+borg create \-\-exclude home/bobby/junk archive /home/bobby /home/susan
+borg create \-\-patterns\-from patternfile.lst archive
 .ft P
 .fi
 .UNINDENT
 .UNINDENT
 .sp
-The patternfile:
+patternfile.lst:
 .INDENT 0.0
 .INDENT 3.5
 .sp
@@ -296,8 +321,7 @@ The patternfile:
 P fm
 R /home/bobby
 R /home/susan
-
-\- /home/bobby/junk
+\- home/bobby/junk
 .ft P
 .fi
 .UNINDENT
diff --git a/docs/man/borg-placeholders.1 b/docs/man/borg-placeholders.1
index 0e9d49688..86d57d485 100644
--- a/docs/man/borg-placeholders.1
+++ b/docs/man/borg-placeholders.1
@@ -1,8 +1,5 @@
 .\" Man page generated from reStructuredText.
 .
-.TH BORG-PLACEHOLDERS 1 "2022-04-14" "" "borg backup tool"
-.SH NAME
-borg-placeholders \- Details regarding placeholders
 .
 .nr rst2man-indent-level 0
 .
@@ -30,9 +27,12 @@ level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .in \\n[rst2man-indent\\n[rst2man-indent-level]]u
 ..
+.TH "BORG-PLACEHOLDERS" 1 "2022-06-25" "" "borg backup tool"
+.SH NAME
+borg-placeholders \- Details regarding placeholders
 .SH DESCRIPTION
 .sp
-Repository (or Archive) URLs, \fB\-\-prefix\fP, \fB\-\-glob\-archives\fP, \fB\-\-comment\fP
+Repository URLs, \fB\-\-name\fP, \fB\-\-prefix\fP, \fB\-\-glob\-archives\fP, \fB\-\-comment\fP
 and \fB\-\-remote\-path\fP values support these placeholders:
 .INDENT 0.0
 .TP
diff --git a/docs/man/borg-prune.1 b/docs/man/borg-prune.1
index 5074d012e..0cbb7f772 100644
--- a/docs/man/borg-prune.1
+++ b/docs/man/borg-prune.1
@@ -1,8 +1,5 @@
 .\" Man page generated from reStructuredText.
 .
-.TH BORG-PRUNE 1 "2022-04-14" "" "borg backup tool"
-.SH NAME
-borg-prune \- Prune repository archives according to specified rules
 .
 .nr rst2man-indent-level 0
 .
@@ -30,9 +27,12 @@ level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .in \\n[rst2man-indent\\n[rst2man-indent-level]]u
 ..
+.TH "BORG-PRUNE" 1 "2022-06-25" "" "borg backup tool"
+.SH NAME
+borg-prune \- Prune repository archives according to specified rules
 .SH SYNOPSIS
 .sp
-borg [common options] prune [options] [REPOSITORY]
+borg [common options] prune [options]
 .SH DESCRIPTION
 .sp
 The prune command prunes a repository by deleting all archives not matching
@@ -91,52 +91,46 @@ Please note that the "All archives" stats refer to the state after pruning.
 .SH OPTIONS
 .sp
 See \fIborg\-common(1)\fP for common options of Borg commands.
-.SS arguments
-.INDENT 0.0
-.TP
-.B REPOSITORY
-repository to prune
-.UNINDENT
 .SS optional arguments
 .INDENT 0.0
 .TP
-.B \-n\fP,\fB  \-\-dry\-run
+.B  \-n\fP,\fB  \-\-dry\-run
 do not change repository
 .TP
-.B \-\-force
+.B  \-\-force
 force pruning of corrupted archives, use \fB\-\-force \-\-force\fP in case \fB\-\-force\fP does not work.
 .TP
-.B \-s\fP,\fB  \-\-stats
+.B  \-s\fP,\fB  \-\-stats
 print statistics for the deleted archive
 .TP
-.B \-\-list
+.B  \-\-list
 output verbose list of archives it keeps/prunes
 .TP
 .BI \-\-keep\-within \ INTERVAL
 keep all archives within this time interval
 .TP
-.B \-\-keep\-last\fP,\fB  \-\-keep\-secondly
+.B  \-\-keep\-last\fP,\fB  \-\-keep\-secondly
 number of secondly archives to keep
 .TP
-.B \-\-keep\-minutely
+.B  \-\-keep\-minutely
 number of minutely archives to keep
 .TP
-.B \-H\fP,\fB  \-\-keep\-hourly
+.B  \-H\fP,\fB  \-\-keep\-hourly
 number of hourly archives to keep
 .TP
-.B \-d\fP,\fB  \-\-keep\-daily
+.B  \-d\fP,\fB  \-\-keep\-daily
 number of daily archives to keep
 .TP
-.B \-w\fP,\fB  \-\-keep\-weekly
+.B  \-w\fP,\fB  \-\-keep\-weekly
 number of weekly archives to keep
 .TP
-.B \-m\fP,\fB  \-\-keep\-monthly
+.B  \-m\fP,\fB  \-\-keep\-monthly
 number of monthly archives to keep
 .TP
-.B \-y\fP,\fB  \-\-keep\-yearly
+.B  \-y\fP,\fB  \-\-keep\-yearly
 number of yearly archives to keep
 .TP
-.B \-\-save\-space
+.B  \-\-save\-space
 work slower, but using less space
 .UNINDENT
 .SS Archive filters
@@ -167,21 +161,21 @@ first so you will see what it would do without it actually doing anything.
 .ft C
 # Keep 7 end of day and 4 additional end of week archives.
 # Do a dry\-run without actually deleting anything.
-$ borg prune \-v \-\-list \-\-dry\-run \-\-keep\-daily=7 \-\-keep\-weekly=4 /path/to/repo
+$ borg prune \-v \-\-list \-\-dry\-run \-\-keep\-daily=7 \-\-keep\-weekly=4
 
 # Same as above but only apply to archive names starting with the hostname
 # of the machine followed by a "\-" character:
-$ borg prune \-v \-\-list \-\-keep\-daily=7 \-\-keep\-weekly=4 \-\-prefix=\(aq{hostname}\-\(aq /path/to/repo
+$ borg prune \-v \-\-list \-\-keep\-daily=7 \-\-keep\-weekly=4 \-\-prefix=\(aq{hostname}\-\(aq
 # actually free disk space:
-$ borg compact /path/to/repo
+$ borg compact
 
 # Keep 7 end of day, 4 additional end of week archives,
 # and an end of month archive for every month:
-$ borg prune \-v \-\-list \-\-keep\-daily=7 \-\-keep\-weekly=4 \-\-keep\-monthly=\-1 /path/to/repo
+$ borg prune \-v \-\-list \-\-keep\-daily=7 \-\-keep\-weekly=4 \-\-keep\-monthly=\-1
 
 # Keep all backups in the last 10 days, 4 additional end of week archives,
 # and an end of month archive for every month:
-$ borg prune \-v \-\-list \-\-keep\-within=10d \-\-keep\-weekly=4 \-\-keep\-monthly=\-1 /path/to/repo
+$ borg prune \-v \-\-list \-\-keep\-within=10d \-\-keep\-weekly=4 \-\-keep\-monthly=\-1
 .ft P
 .fi
 .UNINDENT
diff --git a/docs/man/borg-init.1 b/docs/man/borg-rcreate.1
similarity index 81%
rename from docs/man/borg-init.1
rename to docs/man/borg-rcreate.1
index 25cdf717c..0d500f1d4 100644
--- a/docs/man/borg-init.1
+++ b/docs/man/borg-rcreate.1
@@ -1,8 +1,5 @@
 .\" Man page generated from reStructuredText.
 .
-.TH BORG-INIT 1 "2022-04-14" "" "borg backup tool"
-.SH NAME
-borg-init \- Initialize an empty repository
 .
 .nr rst2man-indent-level 0
 .
@@ -30,12 +27,15 @@ level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .in \\n[rst2man-indent\\n[rst2man-indent-level]]u
 ..
+.TH "BORG-RCREATE" 1 "2022-06-25" "" "borg backup tool"
+.SH NAME
+borg-rcreate \- Create a new, empty repository
 .SH SYNOPSIS
 .sp
-borg [common options] init [options] [REPOSITORY]
+borg [common options] rcreate [options]
 .SH DESCRIPTION
 .sp
-This command initializes an empty repository. A repository is a filesystem
+This command creates a new, empty repository. A repository is a filesystem
 directory containing the deduplicated data from zero or more archives.
 .SS Encryption mode TLDR
 .sp
@@ -48,7 +48,7 @@ tips will come below):
 .sp
 .nf
 .ft C
-borg init \-\-encryption repokey /path/to/repo
+borg rcreate \-\-encryption repokey\-aes\-ocb
 .ft P
 .fi
 .UNINDENT
@@ -122,19 +122,19 @@ center;
 |l|l|l|l|l|.
 _
 T{
-\fBmode (* = keyfile or repokey)\fP
+Mode (K = keyfile or repokey)
 T}	T{
-\fBID\-Hash\fP
+ID\-Hash
 T}	T{
-\fBEncryption\fP
+Encryption
 T}	T{
-\fBAuthentication\fP
+Authentication
 T}	T{
-\fBV>=\fP
+V >=
 T}
 _
 T{
-\fB*\-blake2\-chacha20\-poly1305\fP
+K\-blake2\-chacha20\-poly1305
 T}	T{
 BLAKE2b
 T}	T{
@@ -142,11 +142,11 @@ CHACHA20
 T}	T{
 POLY1305
 T}	T{
-1.3
+2.0
 T}
 _
 T{
-\fB*\-chacha20\-poly1305\fP
+K\-chacha20\-poly1305
 T}	T{
 HMAC\-SHA\-256
 T}	T{
@@ -154,11 +154,11 @@ CHACHA20
 T}	T{
 POLY1305
 T}	T{
-1.3
+2.0
 T}
 _
 T{
-\fB*\-blake2\-aes\-ocb\fP
+K\-blake2\-aes\-ocb
 T}	T{
 BLAKE2b
 T}	T{
@@ -166,11 +166,11 @@ AES256\-OCB
 T}	T{
 AES256\-OCB
 T}	T{
-1.3
+2.0
 T}
 _
 T{
-\fB*\-aes\-ocb\fP
+K\-aes\-ocb
 T}	T{
 HMAC\-SHA\-256
 T}	T{
@@ -178,11 +178,11 @@ AES256\-OCB
 T}	T{
 AES256\-OCB
 T}	T{
-1.3
+2.0
 T}
 _
 T{
-\fB*\-blake2\fP
+K\-blake2
 T}	T{
 BLAKE2b
 T}	T{
@@ -194,7 +194,7 @@ T}	T{
 T}
 _
 T{
-\fB*\fP
+K
 T}	T{
 HMAC\-SHA\-256
 T}	T{
@@ -257,8 +257,6 @@ malicious tampering use an \fIauthenticated\fP mode. It\(aqs like \fIrepokey\fP
 \fB\-\-key\-algorithm argon2\fP is the default and is recommended.
 The key encryption key is derived from your passphrase via argon2\-id.
 Argon2 is considered more modern and secure than pbkdf2.
-.IP \(bu 2
-You can use \fB\-\-key\-algorithm pbkdf2\fP if you want to access your repo via old versions of borg.
 .UNINDENT
 .sp
 Our implementation of argon2\-based key algorithm follows the cryptographic best practices:
@@ -275,28 +273,25 @@ to break backwards compatibility anyway we took the opportunity to fix all 3 iss
 .SH OPTIONS
 .sp
 See \fIborg\-common(1)\fP for common options of Borg commands.
-.SS arguments
-.INDENT 0.0
-.TP
-.B REPOSITORY
-repository to create
-.UNINDENT
 .SS optional arguments
 .INDENT 0.0
 .TP
+.BI \-\-other\-repo \ SRC_REPOSITORY
+reuse the key material from the other repository
+.TP
 .BI \-e \ MODE\fR,\fB \ \-\-encryption \ MODE
 select encryption key mode \fB(required)\fP
 .TP
-.B \-\-append\-only
+.B  \-\-append\-only
 create an append\-only mode repository. Note that this only affects the low level structure of the repository, and running \fIdelete\fP or \fIprune\fP will still be allowed. See \fIappend_only_mode\fP in Additional Notes for more details.
 .TP
 .BI \-\-storage\-quota \ QUOTA
 Set storage quota of the new repository (e.g. 5G, 1.5T). Default: no quota.
 .TP
-.B \-\-make\-parent\-dirs
+.B  \-\-make\-parent\-dirs
 create the parent directories of the repository directory, if they are missing.
 .TP
-.B \-\-key\-algorithm
+.B  \-\-key\-algorithm
 the algorithm we use to derive a key encryption key from your passphrase. Default: argon2
 .UNINDENT
 .SH EXAMPLES
@@ -305,29 +300,30 @@ the algorithm we use to derive a key encryption key from your passphrase. Defaul
 .sp
 .nf
 .ft C
-# Local repository, recommended repokey AEAD crypto modes
-$ borg init \-\-encryption=repokey\-aes\-ocb /path/to/repo
-$ borg init \-\-encryption=repokey\-chacha20\-poly1305 /path/to/repo
-$ borg init \-\-encryption=repokey\-blake2\-aes\-ocb /path/to/repo
-$ borg init \-\-encryption=repokey\-blake2\-chacha20\-poly1305 /path/to/repo
-
-# Local repository (no encryption), not recommended
-$ borg init \-\-encryption=none /path/to/repo
+# Local repository
+$ export BORG_REPO=/path/to/repo
+# recommended repokey AEAD crypto modes
+$ borg rcreate \-\-encryption=repokey\-aes\-ocb
+$ borg rcreate \-\-encryption=repokey\-chacha20\-poly1305
+$ borg rcreate \-\-encryption=repokey\-blake2\-aes\-ocb
+$ borg rcreate \-\-encryption=repokey\-blake2\-chacha20\-poly1305
+# no encryption, not recommended
+$ borg rcreate \-\-encryption=authenticated
+$ borg rcreate \-\-encryption=none
 
 # Remote repository (accesses a remote borg via ssh)
+$ export BORG_REPO=ssh://user@hostname/~/backup
 # repokey: stores the (encrypted) key into <REPO_DIR>/config
-$ borg init \-\-encryption=repokey\-aes\-ocb user@hostname:backup
-
-# Remote repository (accesses a remote borg via ssh)
+$ borg rcreate \-\-encryption=repokey\-aes\-ocb
 # keyfile: stores the (encrypted) key into ~/.config/borg/keys/
-$ borg init \-\-encryption=keyfile\-aes\-ocb user@hostname:backup
+$ borg rcreate \-\-encryption=keyfile\-aes\-ocb
 .ft P
 .fi
 .UNINDENT
 .UNINDENT
 .SH SEE ALSO
 .sp
-\fIborg\-common(1)\fP, \fIborg\-create(1)\fP, \fIborg\-delete(1)\fP, \fIborg\-check(1)\fP, \fIborg\-list(1)\fP, \fIborg\-key\-import(1)\fP, \fIborg\-key\-export(1)\fP, \fIborg\-key\-change\-passphrase(1)\fP
+\fIborg\-common(1)\fP, \fIborg\-rdelete(1)\fP, \fIborg\-rlist(1)\fP, \fIborg\-check(1)\fP, \fIborg\-key\-import(1)\fP, \fIborg\-key\-export(1)\fP, \fIborg\-key\-change\-passphrase(1)\fP
 .SH AUTHOR
 The Borg Collective
 .\" Generated by docutils manpage writer.
diff --git a/docs/man/borg-rdelete.1 b/docs/man/borg-rdelete.1
new file mode 100644
index 000000000..89b837412
--- /dev/null
+++ b/docs/man/borg-rdelete.1
@@ -0,0 +1,90 @@
+.\" Man page generated from reStructuredText.
+.
+.
+.nr rst2man-indent-level 0
+.
+.de1 rstReportMargin
+\\$1 \\n[an-margin]
+level \\n[rst2man-indent-level]
+level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
+-
+\\n[rst2man-indent0]
+\\n[rst2man-indent1]
+\\n[rst2man-indent2]
+..
+.de1 INDENT
+.\" .rstReportMargin pre:
+. RS \\$1
+. nr rst2man-indent\\n[rst2man-indent-level] \\n[an-margin]
+. nr rst2man-indent-level +1
+.\" .rstReportMargin post:
+..
+.de UNINDENT
+. RE
+.\" indent \\n[an-margin]
+.\" old: \\n[rst2man-indent\\n[rst2man-indent-level]]
+.nr rst2man-indent-level -1
+.\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
+.in \\n[rst2man-indent\\n[rst2man-indent-level]]u
+..
+.TH "BORG-RDELETE" 1 "2022-06-25" "" "borg backup tool"
+.SH NAME
+borg-rdelete \- Delete a repository
+.SH SYNOPSIS
+.sp
+borg [common options] rdelete [options]
+.SH DESCRIPTION
+.sp
+This command deletes the complete repository.
+.sp
+When you delete a complete repository, the security info and local cache for it
+(if any) are also deleted. Alternatively, you can delete just the local cache
+with the \fB\-\-cache\-only\fP option, or keep the security info with the
+\fB\-\-keep\-security\-info\fP option.
+.sp
+Always first use \fB\-\-dry\-run \-\-list\fP to see what would be deleted.
+.SH OPTIONS
+.sp
+See \fIborg\-common(1)\fP for common options of Borg commands.
+.SS optional arguments
+.INDENT 0.0
+.TP
+.B  \-n\fP,\fB  \-\-dry\-run
+do not change repository
+.TP
+.B  \-\-list
+output verbose list of archives
+.TP
+.B  \-\-force
+force deletion of corrupted archives, use \fB\-\-force \-\-force\fP in case \fB\-\-force\fP does not work.
+.TP
+.B  \-\-cache\-only
+delete only the local cache for the given repository
+.TP
+.B  \-\-keep\-security\-info
+keep the local security info when deleting a repository
+.UNINDENT
+.SH EXAMPLES
+.INDENT 0.0
+.INDENT 3.5
+.sp
+.nf
+.ft C
+# delete the whole repository and the related local cache:
+$ borg rdelete
+You requested to completely DELETE the repository *including* all archives it contains:
+repo                                 Mon, 2016\-02\-15 19:26:54
+root\-2016\-02\-15                      Mon, 2016\-02\-15 19:36:29
+newname                              Mon, 2016\-02\-15 19:50:19
+Type \(aqYES\(aq if you understand this and want to continue: YES
+.ft P
+.fi
+.UNINDENT
+.UNINDENT
+.SH SEE ALSO
+.sp
+\fIborg\-common(1)\fP
+.SH AUTHOR
+The Borg Collective
+.\" Generated by docutils manpage writer.
+.
diff --git a/docs/man/borg-recreate.1 b/docs/man/borg-recreate.1
index f5847c4fa..475de0696 100644
--- a/docs/man/borg-recreate.1
+++ b/docs/man/borg-recreate.1
@@ -1,8 +1,5 @@
 .\" Man page generated from reStructuredText.
 .
-.TH BORG-RECREATE 1 "2022-04-14" "" "borg backup tool"
-.SH NAME
-borg-recreate \- Re-create archives
 .
 .nr rst2man-indent-level 0
 .
@@ -30,9 +27,12 @@ level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .in \\n[rst2man-indent\\n[rst2man-indent-level]]u
 ..
+.TH "BORG-RECREATE" 1 "2022-06-25" "" "borg backup tool"
+.SH NAME
+borg-recreate \- Re-create archives
 .SH SYNOPSIS
 .sp
-borg [common options] recreate [options] [REPOSITORY_OR_ARCHIVE] [PATH...]
+borg [common options] recreate [options] [PATH...]
 .SH DESCRIPTION
 .sp
 Recreate the contents of existing archives.
@@ -91,25 +91,22 @@ See \fIborg\-common(1)\fP for common options of Borg commands.
 .SS arguments
 .INDENT 0.0
 .TP
-.B REPOSITORY_OR_ARCHIVE
-repository or archive to recreate
-.TP
 .B PATH
 paths to recreate; patterns are supported
 .UNINDENT
 .SS optional arguments
 .INDENT 0.0
 .TP
-.B \-\-list
+.B  \-\-list
 output verbose list of items (files, dirs, ...)
 .TP
 .BI \-\-filter \ STATUSCHARS
 only display items with the given status characters (listed in borg create \-\-help)
 .TP
-.B \-n\fP,\fB  \-\-dry\-run
+.B  \-n\fP,\fB  \-\-dry\-run
 do not change anything
 .TP
-.B \-s\fP,\fB  \-\-stats
+.B  \-s\fP,\fB  \-\-stats
 print statistics at end
 .UNINDENT
 .SS Exclusion options
@@ -127,18 +124,33 @@ include/exclude paths matching PATTERN
 .BI \-\-patterns\-from \ PATTERNFILE
 read include/exclude patterns from PATTERNFILE, one per line
 .TP
-.B \-\-exclude\-caches
+.B  \-\-exclude\-caches
 exclude directories that contain a CACHEDIR.TAG file (\fI\%http://www.bford.info/cachedir/spec.html\fP)
 .TP
 .BI \-\-exclude\-if\-present \ NAME
 exclude directories that are tagged by containing a filesystem object with the given NAME
 .TP
-.B \-\-keep\-exclude\-tags
+.B  \-\-keep\-exclude\-tags
 if tag objects are specified with \fB\-\-exclude\-if\-present\fP, don\(aqt omit the tag objects themselves from the backup archive
 .UNINDENT
-.SS Archive options
+.SS Archive filters
 .INDENT 0.0
 .TP
+.BI \-P \ PREFIX\fR,\fB \ \-\-prefix \ PREFIX
+only consider archive names starting with this prefix.
+.TP
+.BI \-a \ GLOB\fR,\fB \ \-\-glob\-archives \ GLOB
+only consider archive names matching the glob. sh: rules apply, see "borg help patterns". \fB\-\-prefix\fP and \fB\-\-glob\-archives\fP are mutually exclusive.
+.TP
+.BI \-\-sort\-by \ KEYS
+Comma\-separated list of sorting keys; valid keys are: timestamp, name, id; default is: timestamp
+.TP
+.BI \-\-first \ N
+consider first N archives after other filters were applied
+.TP
+.BI \-\-last \ N
+consider last N archives after other filters were applied
+.TP
 .BI \-\-target \ TARGET
 create a new archive with the name ARCHIVE, do not replace existing archive (only applies for a single archive)
 .TP
@@ -166,30 +178,25 @@ specify the chunker parameters (ALGO, CHUNK_MIN_EXP, CHUNK_MAX_EXP, HASH_MASK_BI
 .sp
 .nf
 .ft C
-# Make old (Attic / Borg 0.xx) archives deduplicate with Borg 1.x archives.
-# Archives created with Borg 1.1+ and the default chunker params are skipped
-# (archive ID stays the same).
-$ borg recreate /mnt/backup \-\-chunker\-params default \-\-progress
-
 # Create a backup with little but fast compression
-$ borg create /mnt/backup::archive /some/files \-\-compression lz4
+$ borg create archive /some/files \-\-compression lz4
 # Then compress it \- this might take longer, but the backup has already completed,
 # so no inconsistencies from a long\-running backup job.
-$ borg recreate /mnt/backup::archive \-\-recompress \-\-compression zlib,9
+$ borg recreate \-a archive \-\-recompress \-\-compression zlib,9
 
 # Remove unwanted files from all archives in a repository.
 # Note the relative path for the \-\-exclude option \- archives only contain relative paths.
-$ borg recreate /mnt/backup \-\-exclude home/icke/Pictures/drunk_photos
+$ borg recreate \-\-exclude home/icke/Pictures/drunk_photos
 
 # Change archive comment
-$ borg create \-\-comment "This is a comment" /mnt/backup::archivename ~
-$ borg info /mnt/backup::archivename
+$ borg create \-\-comment "This is a comment" archivename ~
+$ borg info \-a archivename
 Name: archivename
 Fingerprint: ...
 Comment: This is a comment
 \&...
-$ borg recreate \-\-comment "This is a better comment" /mnt/backup::archivename
-$ borg info /mnt/backup::archivename
+$ borg recreate \-\-comment "This is a better comment" \-a archivename
+$ borg info \-a archivename
 Name: archivename
 Fingerprint: ...
 Comment: This is a better comment
diff --git a/docs/man/borg-rename.1 b/docs/man/borg-rename.1
index b00563777..0c5c8051e 100644
--- a/docs/man/borg-rename.1
+++ b/docs/man/borg-rename.1
@@ -1,8 +1,5 @@
 .\" Man page generated from reStructuredText.
 .
-.TH BORG-RENAME 1 "2022-04-14" "" "borg backup tool"
-.SH NAME
-borg-rename \- Rename an existing archive
 .
 .nr rst2man-indent-level 0
 .
@@ -30,9 +27,12 @@ level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .in \\n[rst2man-indent\\n[rst2man-indent-level]]u
 ..
+.TH "BORG-RENAME" 1 "2022-06-25" "" "borg backup tool"
+.SH NAME
+borg-rename \- Rename an existing archive
 .SH SYNOPSIS
 .sp
-borg [common options] rename [options] ARCHIVE NEWNAME
+borg [common options] rename [options] OLDNAME NEWNAME
 .SH DESCRIPTION
 .sp
 This command renames an archive in the repository.
@@ -44,11 +44,11 @@ See \fIborg\-common(1)\fP for common options of Borg commands.
 .SS arguments
 .INDENT 0.0
 .TP
-.B ARCHIVE
-archive to rename
+.B OLDNAME
+specify the archive name
 .TP
 .B NEWNAME
-the new archive name to use
+specify the new archive name
 .UNINDENT
 .SH EXAMPLES
 .INDENT 0.0
@@ -56,12 +56,12 @@ the new archive name to use
 .sp
 .nf
 .ft C
-$ borg create /path/to/repo::archivename ~
-$ borg list /path/to/repo
+$ borg create archivename ~
+$ borg rlist
 archivename                          Mon, 2016\-02\-15 19:50:19
 
-$ borg rename /path/to/repo::archivename newname
-$ borg list /path/to/repo
+$ borg rename archivename newname
+$ borg rlist
 newname                              Mon, 2016\-02\-15 19:50:19
 .ft P
 .fi
diff --git a/docs/man/borg-rinfo.1 b/docs/man/borg-rinfo.1
new file mode 100644
index 000000000..ac0306c6a
--- /dev/null
+++ b/docs/man/borg-rinfo.1
@@ -0,0 +1,83 @@
+.\" Man page generated from reStructuredText.
+.
+.
+.nr rst2man-indent-level 0
+.
+.de1 rstReportMargin
+\\$1 \\n[an-margin]
+level \\n[rst2man-indent-level]
+level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
+-
+\\n[rst2man-indent0]
+\\n[rst2man-indent1]
+\\n[rst2man-indent2]
+..
+.de1 INDENT
+.\" .rstReportMargin pre:
+. RS \\$1
+. nr rst2man-indent\\n[rst2man-indent-level] \\n[an-margin]
+. nr rst2man-indent-level +1
+.\" .rstReportMargin post:
+..
+.de UNINDENT
+. RE
+.\" indent \\n[an-margin]
+.\" old: \\n[rst2man-indent\\n[rst2man-indent-level]]
+.nr rst2man-indent-level -1
+.\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
+.in \\n[rst2man-indent\\n[rst2man-indent-level]]u
+..
+.TH "BORG-RINFO" 1 "2022-06-25" "" "borg backup tool"
+.SH NAME
+borg-rinfo \- Show repository infos
+.SH SYNOPSIS
+.sp
+borg [common options] rinfo [options]
+.SH DESCRIPTION
+.sp
+This command displays detailed information about the repository.
+.sp
+Please note that the deduplicated sizes of the individual archives do not add
+up to the deduplicated size of the repository ("all archives"), because the two
+are meaning different things:
+.sp
+This archive / deduplicated size = amount of data stored ONLY for this archive
+= unique chunks of this archive.
+All archives / deduplicated size = amount of data stored in the repo
+= all chunks in the repository.
+.SH OPTIONS
+.sp
+See \fIborg\-common(1)\fP for common options of Borg commands.
+.SS optional arguments
+.INDENT 0.0
+.TP
+.B  \-\-json
+format output as JSON
+.UNINDENT
+.SH EXAMPLES
+.INDENT 0.0
+.INDENT 3.5
+.sp
+.nf
+.ft C
+$ borg rinfo
+Repository ID: 0e85a7811022326c067acb2a7181d5b526b7d2f61b34470fb8670c440a67f1a9
+Location: /Users/tw/w/borg/path/to/repo
+Encrypted: Yes (repokey AES\-OCB)
+Cache: /Users/tw/.cache/borg/0e85a7811022326c067acb2a7181d5b526b7d2f61b34470fb8670c440a67f1a9
+Security dir: /Users/tw/.config/borg/security/0e85a7811022326c067acb2a7181d5b526b7d2f61b34470fb8670c440a67f1a9
+Original size: 152.14 MB
+Deduplicated size: 30.38 MB
+Unique chunks: 654
+Total chunks: 3302
+.ft P
+.fi
+.UNINDENT
+.UNINDENT
+.SH SEE ALSO
+.sp
+\fIborg\-common(1)\fP
+.SH AUTHOR
+The Borg Collective
+.\" Generated by docutils manpage writer.
+.
diff --git a/docs/man/borg-rlist.1 b/docs/man/borg-rlist.1
new file mode 100644
index 000000000..d85a1ff85
--- /dev/null
+++ b/docs/man/borg-rlist.1
@@ -0,0 +1,160 @@
+.\" Man page generated from reStructuredText.
+.
+.
+.nr rst2man-indent-level 0
+.
+.de1 rstReportMargin
+\\$1 \\n[an-margin]
+level \\n[rst2man-indent-level]
+level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
+-
+\\n[rst2man-indent0]
+\\n[rst2man-indent1]
+\\n[rst2man-indent2]
+..
+.de1 INDENT
+.\" .rstReportMargin pre:
+. RS \\$1
+. nr rst2man-indent\\n[rst2man-indent-level] \\n[an-margin]
+. nr rst2man-indent-level +1
+.\" .rstReportMargin post:
+..
+.de UNINDENT
+. RE
+.\" indent \\n[an-margin]
+.\" old: \\n[rst2man-indent\\n[rst2man-indent-level]]
+.nr rst2man-indent-level -1
+.\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
+.in \\n[rst2man-indent\\n[rst2man-indent-level]]u
+..
+.TH "BORG-RLIST" 1 "2022-06-25" "" "borg backup tool"
+.SH NAME
+borg-rlist \- List the archives contained in a repository
+.SH SYNOPSIS
+.sp
+borg [common options] rlist [options]
+.SH DESCRIPTION
+.sp
+This command lists the archives contained in a repository.
+.SH OPTIONS
+.sp
+See \fIborg\-common(1)\fP for common options of Borg commands.
+.SS optional arguments
+.INDENT 0.0
+.TP
+.B  \-\-consider\-checkpoints
+Show checkpoint archives in the repository contents list (default: hidden).
+.TP
+.B  \-\-short
+only print the archive names, nothing else
+.TP
+.BI \-\-format \ FORMAT
+specify format for archive listing (default: "{archive:<36} {time} [{id}]{NL}")
+.TP
+.B  \-\-json
+Format output as JSON. The form of \fB\-\-format\fP is ignored, but keys used in it are added to the JSON output. Some keys are always present. Note: JSON can only represent text. A "barchive" key is therefore not available.
+.UNINDENT
+.SS Archive filters
+.INDENT 0.0
+.TP
+.BI \-P \ PREFIX\fR,\fB \ \-\-prefix \ PREFIX
+only consider archive names starting with this prefix.
+.TP
+.BI \-a \ GLOB\fR,\fB \ \-\-glob\-archives \ GLOB
+only consider archive names matching the glob. sh: rules apply, see "borg help patterns". \fB\-\-prefix\fP and \fB\-\-glob\-archives\fP are mutually exclusive.
+.TP
+.BI \-\-sort\-by \ KEYS
+Comma\-separated list of sorting keys; valid keys are: timestamp, name, id; default is: timestamp
+.TP
+.BI \-\-first \ N
+consider first N archives after other filters were applied
+.TP
+.BI \-\-last \ N
+consider last N archives after other filters were applied
+.UNINDENT
+.SH EXAMPLES
+.INDENT 0.0
+.INDENT 3.5
+.sp
+.nf
+.ft C
+$ borg rlist
+Monday                               Mon, 2016\-02\-15 19:15:11
+repo                                 Mon, 2016\-02\-15 19:26:54
+root\-2016\-02\-15                      Mon, 2016\-02\-15 19:36:29
+newname                              Mon, 2016\-02\-15 19:50:19
+\&...
+.ft P
+.fi
+.UNINDENT
+.UNINDENT
+.SH NOTES
+.SS The FORMAT specifier syntax
+.sp
+The \fB\-\-format\fP option uses python\(aqs \fI\%format string syntax\fP\&.
+.sp
+Examples:
+.INDENT 0.0
+.INDENT 3.5
+.sp
+.nf
+.ft C
+$ borg rlist \-\-format \(aq{archive}{NL}\(aq
+ArchiveFoo
+ArchiveBar
+\&...
+
+# {VAR:NUMBER} \- pad to NUMBER columns.
+# Strings are left\-aligned, numbers are right\-aligned.
+# Note: time columns except \(ga\(gaisomtime\(ga\(ga, \(ga\(gaisoctime\(ga\(ga and \(ga\(gaisoatime\(ga\(ga cannot be padded.
+$ borg rlist \-\-format \(aq{archive:36} {time} [{id}]{NL}\(aq /path/to/repo
+ArchiveFoo                           Thu, 2021\-12\-09 10:22:28 [0b8e9a312bef3f2f6e2d0fc110c196827786c15eba0188738e81697a7fa3b274]
+\&...
+.ft P
+.fi
+.UNINDENT
+.UNINDENT
+.sp
+The following keys are always available:
+\- NEWLINE: OS dependent line separator
+\- NL: alias of NEWLINE
+\- NUL: NUL character for creating print0 / xargs \-0 like output, see barchive and bpath keys below
+\- SPACE
+\- TAB
+\- CR
+\- LF
+.sp
+Keys available only when listing archives in a repository:
+.INDENT 0.0
+.IP \(bu 2
+archive: archive name interpreted as text (might be missing non\-text characters, see barchive)
+.IP \(bu 2
+name: alias of "archive"
+.IP \(bu 2
+barchive: verbatim archive name, can contain any character except NUL
+.IP \(bu 2
+comment: archive comment interpreted as text (might be missing non\-text characters, see bcomment)
+.IP \(bu 2
+bcomment: verbatim archive comment, can contain any character except NUL
+.IP \(bu 2
+id: internal ID of the archive
+.IP \(bu 2
+start: time (start) of creation of the archive
+.IP \(bu 2
+time: alias of "start"
+.IP \(bu 2
+end: time (end) of creation of the archive
+.IP \(bu 2
+command_line: command line which was used to create the archive
+.IP \(bu 2
+hostname: hostname of host on which this archive was created
+.IP \(bu 2
+username: username of user who created this archive
+.UNINDENT
+.SH SEE ALSO
+.sp
+\fIborg\-common(1)\fP
+.SH AUTHOR
+The Borg Collective
+.\" Generated by docutils manpage writer.
+.
diff --git a/docs/man/borg-serve.1 b/docs/man/borg-serve.1
index ec7073deb..3660920ba 100644
--- a/docs/man/borg-serve.1
+++ b/docs/man/borg-serve.1
@@ -1,8 +1,5 @@
 .\" Man page generated from reStructuredText.
 .
-.TH BORG-SERVE 1 "2022-04-14" "" "borg backup tool"
-.SH NAME
-borg-serve \- Start in server mode. This command is usually not used manually.
 .
 .nr rst2man-indent-level 0
 .
@@ -30,6 +27,9 @@ level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .in \\n[rst2man-indent\\n[rst2man-indent-level]]u
 ..
+.TH "BORG-SERVE" 1 "2022-06-25" "" "borg backup tool"
+.SH NAME
+borg-serve \- Start in server mode. This command is usually not used manually.
 .SH SYNOPSIS
 .sp
 borg [common options] serve [options]
@@ -48,7 +48,7 @@ restrict repository access to PATH. Can be specified multiple times to allow the
 .BI \-\-restrict\-to\-repository \ PATH
 restrict repository access. Only the repository located at PATH (no sub\-directories are considered) is accessible. Can be specified multiple times to allow the client access to several repositories. Unlike \fB\-\-restrict\-to\-path\fP sub\-directories are not accessible; PATH needs to directly point at a repository location. PATH may be an empty directory or the last element of PATH may not exist, in which case the client may initialize a repository there.
 .TP
-.B \-\-append\-only
+.B  \-\-append\-only
 only allow appending to repository segment files. Note that this only affects the low level structure of the repository, and running \fIdelete\fP or \fIprune\fP will still be allowed. See \fIappend_only_mode\fP in Additional Notes for more details.
 .TP
 .BI \-\-storage\-quota \ QUOTA
diff --git a/docs/man/borg-transfer.1 b/docs/man/borg-transfer.1
new file mode 100644
index 000000000..6832973a9
--- /dev/null
+++ b/docs/man/borg-transfer.1
@@ -0,0 +1,100 @@
+.\" Man page generated from reStructuredText.
+.
+.
+.nr rst2man-indent-level 0
+.
+.de1 rstReportMargin
+\\$1 \\n[an-margin]
+level \\n[rst2man-indent-level]
+level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
+-
+\\n[rst2man-indent0]
+\\n[rst2man-indent1]
+\\n[rst2man-indent2]
+..
+.de1 INDENT
+.\" .rstReportMargin pre:
+. RS \\$1
+. nr rst2man-indent\\n[rst2man-indent-level] \\n[an-margin]
+. nr rst2man-indent-level +1
+.\" .rstReportMargin post:
+..
+.de UNINDENT
+. RE
+.\" indent \\n[an-margin]
+.\" old: \\n[rst2man-indent\\n[rst2man-indent-level]]
+.nr rst2man-indent-level -1
+.\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
+.in \\n[rst2man-indent\\n[rst2man-indent-level]]u
+..
+.TH "BORG-TRANSFER" 1 "2022-06-25" "" "borg backup tool"
+.SH NAME
+borg-transfer \- archives transfer from other repository
+.SH SYNOPSIS
+.sp
+borg [common options] transfer [options]
+.SH DESCRIPTION
+.sp
+This command transfers archives from one repository to another repository.
+.sp
+Suggested use:
+.INDENT 0.0
+.INDENT 3.5
+.sp
+.nf
+.ft C
+# initialize DST_REPO reusing key material from SRC_REPO, so that
+# chunking and chunk id generation will work in the same way as before.
+borg \-\-repo=DST_REPO init \-\-other\-repo=SRC_REPO \-\-encryption=DST_ENC
+
+# transfer archives from SRC_REPO to DST_REPO
+borg \-\-repo=DST_REPO transfer \-\-other\-repo=SRC_REPO \-\-dry\-run  # check what it would do
+borg \-\-repo=DST_REPO transfer \-\-other\-repo=SRC_REPO            # do it!
+borg \-\-repo=DST_REPO transfer \-\-other\-repo=SRC_REPO \-\-dry\-run  # check! anything left?
+.ft P
+.fi
+.UNINDENT
+.UNINDENT
+.sp
+The default is to transfer all archives, including checkpoint archives.
+.sp
+You could use the misc. archive filter options to limit which archives it will
+transfer, e.g. using the \-a option. This is recommended for big
+repositories with multiple data sets to keep the runtime per invocation lower.
+.SH OPTIONS
+.sp
+See \fIborg\-common(1)\fP for common options of Borg commands.
+.SS optional arguments
+.INDENT 0.0
+.TP
+.B  \-n\fP,\fB  \-\-dry\-run
+do not change repository, just check
+.TP
+.BI \-\-other\-repo \ SRC_REPOSITORY
+transfer archives from the other repository
+.UNINDENT
+.SS Archive filters
+.INDENT 0.0
+.TP
+.BI \-P \ PREFIX\fR,\fB \ \-\-prefix \ PREFIX
+only consider archive names starting with this prefix.
+.TP
+.BI \-a \ GLOB\fR,\fB \ \-\-glob\-archives \ GLOB
+only consider archive names matching the glob. sh: rules apply, see "borg help patterns". \fB\-\-prefix\fP and \fB\-\-glob\-archives\fP are mutually exclusive.
+.TP
+.BI \-\-sort\-by \ KEYS
+Comma\-separated list of sorting keys; valid keys are: timestamp, name, id; default is: timestamp
+.TP
+.BI \-\-first \ N
+consider first N archives after other filters were applied
+.TP
+.BI \-\-last \ N
+consider last N archives after other filters were applied
+.UNINDENT
+.SH SEE ALSO
+.sp
+\fIborg\-common(1)\fP
+.SH AUTHOR
+The Borg Collective
+.\" Generated by docutils manpage writer.
+.
diff --git a/docs/man/borg-umount.1 b/docs/man/borg-umount.1
index 8ece60c7f..24b62fc95 100644
--- a/docs/man/borg-umount.1
+++ b/docs/man/borg-umount.1
@@ -1,8 +1,5 @@
 .\" Man page generated from reStructuredText.
 .
-.TH BORG-UMOUNT 1 "2022-04-14" "" "borg backup tool"
-.SH NAME
-borg-umount \- un-mount the FUSE filesystem
 .
 .nr rst2man-indent-level 0
 .
@@ -30,6 +27,9 @@ level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .in \\n[rst2man-indent\\n[rst2man-indent-level]]u
 ..
+.TH "BORG-UMOUNT" 1 "2022-06-25" "" "borg backup tool"
+.SH NAME
+borg-umount \- un-mount the FUSE filesystem
 .SH SYNOPSIS
 .sp
 borg [common options] umount [options] MOUNTPOINT
@@ -57,21 +57,14 @@ mountpoint of the filesystem to umount
 # Mounting the repository shows all archives.
 # Archives are loaded lazily, expect some delay when navigating to an archive
 # for the first time.
-$ borg mount /path/to/repo /tmp/mymountpoint
+$ borg mount /tmp/mymountpoint
 $ ls /tmp/mymountpoint
 root\-2016\-02\-14 root\-2016\-02\-15
 $ borg umount /tmp/mymountpoint
 
-# Mounting a specific archive is possible as well.
-$ borg mount /path/to/repo::root\-2016\-02\-15 /tmp/mymountpoint
-$ ls /tmp/mymountpoint
-bin  boot  etc      home  lib  lib64  lost+found  media  mnt  opt
-root  sbin  srv  tmp  usr  var
-$ borg umount /tmp/mymountpoint
-
 # The "versions view" merges all archives in the repository
 # and provides a versioned view on files.
-$ borg mount \-o versions /path/to/repo /tmp/mymountpoint
+$ borg mount \-o versions /tmp/mymountpoint
 $ ls \-l /tmp/mymountpoint/home/user/doc.txt/
 total 24
 \-rw\-rw\-r\-\- 1 user group 12357 Aug 26 21:19 doc.cda00bc9.txt
@@ -81,12 +74,12 @@ $ borg umount /tmp/mymountpoint
 # Archive filters are supported.
 # These are especially handy for the "versions view",
 # which does not support lazy processing of archives.
-$ borg mount \-o versions \-\-glob\-archives \(aq*\-my\-home\(aq \-\-last 10 /path/to/repo /tmp/mymountpoint
+$ borg mount \-o versions \-\-glob\-archives \(aq*\-my\-home\(aq \-\-last 10 /tmp/mymountpoint
 
 # Exclusion options are supported.
 # These can speed up mounting and lower memory needs significantly.
 $ borg mount /path/to/repo /tmp/mymountpoint only/that/path
-$ borg mount \-\-exclude \(aq...\(aq /path/to/repo /tmp/mymountpoint
+$ borg mount \-\-exclude \(aq...\(aq /tmp/mymountpoint
 .ft P
 .fi
 .UNINDENT
@@ -98,13 +91,9 @@ $ borg mount \-\-exclude \(aq...\(aq /path/to/repo /tmp/mymountpoint
 .nf
 .ft C
 $ echo \(aq/mnt/backup /tmp/myrepo fuse.borgfs defaults,noauto 0 0\(aq >> /etc/fstab
-$ echo \(aq/mnt/backup::root\-2016\-02\-15 /tmp/myarchive fuse.borgfs defaults,noauto 0 0\(aq >> /etc/fstab
 $ mount /tmp/myrepo
-$ mount /tmp/myarchive
 $ ls /tmp/myrepo
 root\-2016\-02\-01 root\-2016\-02\-2015
-$ ls /tmp/myarchive
-bin  boot  etc      home  lib  lib64  lost+found  media  mnt  opt  root  sbin  srv  tmp  usr  var
 .ft P
 .fi
 .UNINDENT
diff --git a/docs/man/borg-upgrade.1 b/docs/man/borg-upgrade.1
index 55c6fc0e0..ffaf7e68f 100644
--- a/docs/man/borg-upgrade.1
+++ b/docs/man/borg-upgrade.1
@@ -1,8 +1,5 @@
 .\" Man page generated from reStructuredText.
 .
-.TH BORG-UPGRADE 1 "2022-04-14" "" "borg backup tool"
-.SH NAME
-borg-upgrade \- upgrade a repository from a previous version
 .
 .nr rst2man-indent-level 0
 .
@@ -30,9 +27,12 @@ level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .in \\n[rst2man-indent\\n[rst2man-indent-level]]u
 ..
+.TH "BORG-UPGRADE" 1 "2022-06-25" "" "borg backup tool"
+.SH NAME
+borg-upgrade \- upgrade a repository from a previous version
 .SH SYNOPSIS
 .sp
-borg [common options] upgrade [options] [REPOSITORY]
+borg [common options] upgrade [options]
 .SH DESCRIPTION
 .sp
 Upgrade an existing, local Borg repository.
@@ -84,28 +84,22 @@ See \fB\-\-chunker\-params\fP option of \fBborg create\fP and \fBborg recreate\f
 .SH OPTIONS
 .sp
 See \fIborg\-common(1)\fP for common options of Borg commands.
-.SS arguments
-.INDENT 0.0
-.TP
-.B REPOSITORY
-path to the repository to be upgraded
-.UNINDENT
 .SS optional arguments
 .INDENT 0.0
 .TP
-.B \-n\fP,\fB  \-\-dry\-run
+.B  \-n\fP,\fB  \-\-dry\-run
 do not change repository
 .TP
-.B \-\-inplace
+.B  \-\-inplace
 rewrite repository in place, with no chance of going back to older versions of the repository.
 .TP
-.B \-\-force
+.B  \-\-force
 Force upgrade
 .TP
-.B \-\-tam
+.B  \-\-tam
 Enable manifest authentication (in key and cache) (Borg 1.0.9 and later).
 .TP
-.B \-\-disable\-tam
+.B  \-\-disable\-tam
 Disable manifest authentication (in key and cache).
 .UNINDENT
 .SH EXAMPLES
diff --git a/docs/man/borg-with-lock.1 b/docs/man/borg-with-lock.1
index e0d6dc237..a3cca32e9 100644
--- a/docs/man/borg-with-lock.1
+++ b/docs/man/borg-with-lock.1
@@ -1,8 +1,5 @@
 .\" Man page generated from reStructuredText.
 .
-.TH BORG-WITH-LOCK 1 "2022-04-14" "" "borg backup tool"
-.SH NAME
-borg-with-lock \- run a user specified command with the repository lock held
 .
 .nr rst2man-indent-level 0
 .
@@ -30,9 +27,12 @@ level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .in \\n[rst2man-indent\\n[rst2man-indent-level]]u
 ..
+.TH "BORG-WITH-LOCK" 1 "2022-06-25" "" "borg backup tool"
+.SH NAME
+borg-with-lock \- run a user specified command with the repository lock held
 .SH SYNOPSIS
 .sp
-borg [common options] with\-lock [options] REPOSITORY COMMAND [ARGS...]
+borg [common options] with\-lock [options] COMMAND [ARGS...]
 .SH DESCRIPTION
 .sp
 This command runs a user\-specified command while the repository lock is held.
@@ -57,9 +57,6 @@ See \fIborg\-common(1)\fP for common options of Borg commands.
 .SS arguments
 .INDENT 0.0
 .TP
-.B REPOSITORY
-repository to lock
-.TP
 .B COMMAND
 command to run
 .TP
diff --git a/docs/man/borg.1 b/docs/man/borg.1
index d69afcf5a..16bfdddf1 100644
--- a/docs/man/borg.1
+++ b/docs/man/borg.1
@@ -1,8 +1,5 @@
 .\" Man page generated from reStructuredText.
 .
-.TH BORG 1 "2022-04-14" "" "borg backup tool"
-.SH NAME
-borg \- deduplicating and encrypting backup tool
 .
 .nr rst2man-indent-level 0
 .
@@ -30,6 +27,9 @@ level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .in \\n[rst2man-indent\\n[rst2man-indent-level]]u
 ..
+.TH "BORG" 1 "2022-06-25" "" "borg backup tool"
+.SH NAME
+borg \- deduplicating and encrypting backup tool
 .SH SYNOPSIS
 .sp
 borg [common options] <command> [options] [arguments]
@@ -60,7 +60,7 @@ Before a backup can be made a repository has to be initialized:
 .sp
 .nf
 .ft C
-$ borg init \-\-encryption=repokey /path/to/repo
+$ borg \-r /path/to/repo rcreate \-\-encryption=repokey\-aes\-ocb
 .ft P
 .fi
 .UNINDENT
@@ -73,7 +73,7 @@ Backup the \fB~/src\fP and \fB~/Documents\fP directories into an archive called
 .sp
 .nf
 .ft C
-$ borg create /path/to/repo::Monday ~/src ~/Documents
+$ borg \-r /path/to/repo create Monday ~/src ~/Documents
 .ft P
 .fi
 .UNINDENT
@@ -85,7 +85,7 @@ The next day create a new archive called \fITuesday\fP:
 .sp
 .nf
 .ft C
-$ borg create \-\-stats /path/to/repo::Tuesday ~/src ~/Documents
+$ borg \-r /path/to/repo create \-\-stats Tuesday ~/src ~/Documents
 .ft P
 .fi
 .UNINDENT
@@ -93,29 +93,23 @@ $ borg create \-\-stats /path/to/repo::Tuesday ~/src ~/Documents
 .sp
 This backup will be a lot quicker and a lot smaller since only new never
 before seen data is stored. The \fB\-\-stats\fP option causes Borg to
-output statistics about the newly created archive such as the amount of unique
-data (not shared with other archives):
+output statistics about the newly created archive such as the deduplicated
+size (the amount of unique data not shared with other archives):
 .INDENT 3.0
 .INDENT 3.5
 .sp
 .nf
 .ft C
-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-
+Repository: /path/to/repo
 Archive name: Tuesday
-Archive fingerprint: bd31004d58f51ea06ff735d2e5ac49376901b21d58035f8fb05dbf866566e3c2
-Time (start): Tue, 2016\-02\-16 18:15:11
-Time (end):   Tue, 2016\-02\-16 18:15:11
-
-Duration: 0.19 seconds
-Number of files: 127
-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-
-                      Original size      Compressed size    Deduplicated size
-This archive:                4.16 MB              4.17 MB             26.78 kB
-All archives:                8.33 MB              8.34 MB              4.19 MB
-
-                      Unique chunks         Total chunks
-Chunk index:                     132                  261
-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-
+Archive fingerprint: bcd1b53f9b4991b7afc2b339f851b7ffe3c6d030688936fe4552eccc1877718d
+Time (start): Sat, 2022\-06\-25 20:21:43
+Time (end):   Sat, 2022\-06\-25 20:21:43
+Duration: 0.07 seconds
+Utilization of max. archive size: 0%
+Number of files: 699
+Original size: 31.14 MB
+Deduplicated size: 502 B
 .ft P
 .fi
 .UNINDENT
@@ -127,9 +121,9 @@ List all archives in the repository:
 .sp
 .nf
 .ft C
-$ borg list /path/to/repo
-Monday                               Mon, 2016\-02\-15 19:14:44
-Tuesday                              Tue, 2016\-02\-16 19:15:11
+$ borg \-r /path/to/repo rlist
+Monday                               Sat, 2022\-06\-25 20:21:14 [b80e24d2...b179f298]
+Tuesday                              Sat, 2022\-06\-25 20:21:43 [bcd1b53f...1877718d]
 .ft P
 .fi
 .UNINDENT
@@ -141,7 +135,7 @@ List the contents of the \fIMonday\fP archive:
 .sp
 .nf
 .ft C
-$ borg list /path/to/repo::Monday
+$ borg \-r /path/to/repo list Monday
 drwxr\-xr\-x user   group          0 Mon, 2016\-02\-15 18:22:30 home/user/Documents
 \-rw\-r\-\-r\-\- user   group       7961 Mon, 2016\-02\-15 18:22:30 home/user/Documents/Important.doc
 \&...
@@ -156,7 +150,7 @@ Restore the \fIMonday\fP archive by extracting the files relative to the current
 .sp
 .nf
 .ft C
-$ borg extract /path/to/repo::Monday
+$ borg \-r /path/to/repo extract Monday
 .ft P
 .fi
 .UNINDENT
@@ -168,11 +162,16 @@ Delete the \fIMonday\fP archive (please note that this does \fBnot\fP free repo
 .sp
 .nf
 .ft C
-$ borg delete /path/to/repo::Monday
+$ borg \-r /path/to/repo delete \-a Monday
 .ft P
 .fi
 .UNINDENT
 .UNINDENT
+.sp
+Please note the \fB\-a\fP option here (short for \fB\-\-glob\-archives\fP) which enables you
+to give a globbing pattern to delete multiple archives, like \fB\-a \(aqoldcrap\-*\(aq\fP\&.
+You can also combine this with \fB\-\-first\fP, \fB\-\-last\fP and \fB\-\-sort\-by\fP\&.
+Be careful, always first use with \fB\-\-dry\-run\fP and \fB\-\-list\fP!
 .IP 8. 3
 Recover disk space by compacting the segment files in the repo:
 .INDENT 3.0
@@ -180,7 +179,7 @@ Recover disk space by compacting the segment files in the repo:
 .sp
 .nf
 .ft C
-$ borg compact /path/to/repo
+$ borg \-r /path/to/repo compact
 .ft P
 .fi
 .UNINDENT
@@ -208,10 +207,10 @@ in the example), but not in between them:
 .sp
 .nf
 .ft C
-borg create \-s \-\-progress repo::archive path  # good and preferred
-borg create repo::archive path \-s \-\-progress  # also works
-borg create \-s repo::archive path \-\-progress  # works, but ugly
-borg create repo::archive \-s \-\-progress path  # BAD
+borg create \-s \-\-progress archive path  # good and preferred
+borg create archive path \-s \-\-progress  # also works
+borg create \-s archive path \-\-progress  # works, but ugly
+borg create archive \-s \-\-progress path  # BAD
 .ft P
 .fi
 .UNINDENT
@@ -233,22 +232,7 @@ Note: you may also prepend a \fBfile://\fP to a filesystem path to get URL style
 .sp
 \fBRemote repositories\fP accessed via ssh \fI\%user@host\fP:
 .sp
-\fBuser@host:/path/to/repo\fP \- remote repo, absolute path
-.sp
-\fBssh://user@host:port/path/to/repo\fP \- same, alternative syntax, port can be given
-.sp
-\fBRemote repositories with relative paths\fP can be given using this syntax:
-.sp
-\fBuser@host:path/to/repo\fP \- path relative to current directory
-.sp
-\fBuser@host:~/path/to/repo\fP \- path relative to user\(aqs home directory
-.sp
-\fBuser@host:~other/path/to/repo\fP \- path relative to other\(aqs home directory
-.sp
-Note: giving \fBuser@host:/./path/to/repo\fP or \fBuser@host:/~/path/to/repo\fP or
-\fBuser@host:/~other/path/to/repo\fP is also supported, but not required here.
-.sp
-\fBRemote repositories with relative paths, alternative syntax with port\fP:
+\fBssh://user@host:port/path/to/repo\fP \- absolute path\(ga
 .sp
 \fBssh://user@host:port/./path/to/repo\fP \- path relative to current directory
 .sp
@@ -269,23 +253,21 @@ export BORG_REPO=\(aqssh://user@host:port/path/to/repo\(aq
 .UNINDENT
 .UNINDENT
 .sp
-Then just leave away the repo URL if only a repo URL is needed and you want
+Then just leave away the \fB\-\-repo\fP option if you want
 to use the default \- it will be read from BORG_REPO then.
+.SS Repository Locations / Archive names
 .sp
-Use \fB::\fP syntax to give the repo URL when syntax requires giving a positional
-argument for the repo (e.g. \fBborg mount :: /mnt\fP).
-.SS Repository / Archive Locations
+Many commands need to know the repository location, give it via \fB\-r\fP / \fB\-\-repo\fP
+or use the \fBBORG_REPO\fP environment variable.
 .sp
-Many commands want either a repository (just give the repo URL, see above) or
-an archive location, which is a repo URL followed by \fB::archive_name\fP\&.
+Commands needing one or two archive names usually get them as positional argument.
+.sp
+Commands working with an arbitrary amount of archives, usually take \fB\-a ARCH_GLOB\fP\&.
 .sp
 Archive names must not contain the \fB/\fP (slash) character. For simplicity,
 maybe also avoid blanks or other characters that have special meaning on the
 shell or in a filesystem (borg mount will use the archive name as directory
 name).
-.sp
-If you have set BORG_REPO (see above) and an archive location is needed, use
-\fB::archive_name\fP \- the repo URL part is then read from BORG_REPO.
 .SS Logging
 .sp
 Borg writes all log output to stderr by default. But please note that something
@@ -391,9 +373,11 @@ Borg uses some environment variables for automation:
 .INDENT 7.0
 .TP
 .B BORG_REPO
-When set, use the value to give the default repository location. If a command needs an archive
-parameter, you can abbreviate as \fB::archive\fP\&. If a command needs a repository parameter, you
-can either leave it away or abbreviate as \fB::\fP, if a positional parameter is required.
+When set, use the value to give the default repository location.
+Use this so you do not need to type \fB\-\-repo /path/to/my/repo\fP all the time.
+.TP
+.B BORG_OTHER_REPO
+Similar to BORG_REPO, but gives the default for \fB\-\-other\-repo\fP\&.
 .TP
 .B BORG_PASSPHRASE
 When set, use the value to answer the passphrase question for encrypted repositories.
@@ -614,7 +598,8 @@ know a list of affected hardware.
 If you are suspicious whether your Borg repository is still consistent
 and readable after one of the failures mentioned above occurred, run
 \fBborg check \-\-verify\-data\fP to make sure it is consistent.
-Requirements for Borg repository file systems.INDENT 0.0
+Requirements for Borg repository file systems
+.INDENT 0.0
 .IP \(bu 2
 Long file names
 .IP \(bu 2
@@ -772,7 +757,7 @@ special file \fIcontents\fP can be backed up in \fB\-\-read\-special\fP mode.
 By default the metadata to create them with mknod(2), mkfifo(2) etc. is stored.
 .UNINDENT
 .IP \(bu 2
-hardlinked regular files, devices, FIFOs (considering all items in the same archive)
+hardlinked regular files, devices, symlinks, FIFOs (considering all items in the same archive)
 .IP \(bu 2
 timestamps in nanosecond precision: mtime, atime, ctime
 .IP \(bu 2
@@ -907,10 +892,10 @@ The BSDs define additional flags.
 .sp
 \fIborg\-common(1)\fP for common command line options
 .sp
-\fIborg\-init(1)\fP,
+\fIborg\-rcreate(1)\fP, \fIborg\-rdelete(1)\fP, \fIborg\-rlist(1)\fP, \fIborg\-rinfo(1)\fP,
 \fIborg\-create(1)\fP, \fIborg\-mount(1)\fP, \fIborg\-extract(1)\fP,
 \fIborg\-list(1)\fP, \fIborg\-info(1)\fP,
-\fIborg\-delete(1)\fP, \fIborg\-prune(1)\fP,
+\fIborg\-delete(1)\fP, \fIborg\-prune(1)\fP, \fIborg\-compact(1)\fP,
 \fIborg\-recreate(1)\fP
 .sp
 \fIborg\-compression(1)\fP, \fIborg\-patterns(1)\fP, \fIborg\-placeholders(1)\fP
diff --git a/docs/man/borgfs.1 b/docs/man/borgfs.1
index 5bcec9d6a..1225418ce 100644
--- a/docs/man/borgfs.1
+++ b/docs/man/borgfs.1
@@ -1,8 +1,5 @@
 .\" Man page generated from reStructuredText.
 .
-.TH BORGFS 1 "2022-04-14" "" "borg backup tool"
-.SH NAME
-borgfs \- Mount archive or an entire repository as a FUSE filesystem
 .
 .nr rst2man-indent-level 0
 .
@@ -30,9 +27,12 @@ level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .in \\n[rst2man-indent\\n[rst2man-indent-level]]u
 ..
+.TH "BORGFS" 1 "2022-06-25" "" "borg backup tool"
+.SH NAME
+borgfs \- Mount archive or an entire repository as a FUSE filesystem
 .SH SYNOPSIS
 .sp
-borgfs [options] REPOSITORY_OR_ARCHIVE MOUNTPOINT [PATH...]
+borgfs [options] MOUNTPOINT [PATH...]
 .SH DESCRIPTION
 .sp
 This command mounts an archive as a FUSE filesystem. This can be useful for
@@ -98,9 +98,6 @@ See \fIborg\-common(1)\fP for common options of Borg commands.
 .SS arguments
 .INDENT 0.0
 .TP
-.B REPOSITORY_OR_ARCHIVE
-repository or archive to mount
-.TP
 .B MOUNTPOINT
 where to mount filesystem
 .TP
@@ -110,22 +107,22 @@ paths to extract; patterns are supported
 .SS optional arguments
 .INDENT 0.0
 .TP
-.B \-V\fP,\fB  \-\-version
+.B  \-V\fP,\fB  \-\-version
 show version number and exit
 .TP
-.B \-\-consider\-checkpoints
+.B  \-\-consider\-checkpoints
 Show checkpoint archives in the repository contents list (default: hidden).
 .TP
-.B \-f\fP,\fB  \-\-foreground
+.B  \-f\fP,\fB  \-\-foreground
 stay in foreground, do not daemonize
 .TP
-.B \-o
+.B  \-o
 Extra mount options
 .TP
-.B \-\-numeric\-owner
+.B  \-\-numeric\-owner
 deprecated, use \fB\-\-numeric\-ids\fP instead
 .TP
-.B \-\-numeric\-ids
+.B  \-\-numeric\-ids
 use numeric user and group identifiers from archive(s)
 .UNINDENT
 .SS Archive filters
diff --git a/docs/man_intro.rst b/docs/man_intro.rst
index e9ed1fd20..0a072f623 100644
--- a/docs/man_intro.rst
+++ b/docs/man_intro.rst
@@ -42,10 +42,10 @@ SEE ALSO
 
 `borg-common(1)` for common command line options
 
-`borg-init(1)`,
+`borg-rcreate(1)`, `borg-rdelete(1)`, `borg-rlist(1)`, `borg-rinfo(1)`,
 `borg-create(1)`, `borg-mount(1)`, `borg-extract(1)`,
 `borg-list(1)`, `borg-info(1)`,
-`borg-delete(1)`, `borg-prune(1)`,
+`borg-delete(1)`, `borg-prune(1)`, `borg-compact(1)`,
 `borg-recreate(1)`
 
 `borg-compression(1)`, `borg-patterns(1)`, `borg-placeholders(1)`
diff --git a/docs/quickstart.rst b/docs/quickstart.rst
index 9ad910d5b..5c33d3857 100644
--- a/docs/quickstart.rst
+++ b/docs/quickstart.rst
@@ -39,7 +39,7 @@ on file systems which do not support this mechanism (e.g. XFS) we recommend to r
 some space in Borg itself just to be safe by adjusting the ``additional_free_space``
 setting (a good starting point is ``2G``)::
 
-    borg config /path/to/repo additional_free_space 2G
+    borg config additional_free_space 2G
 
 If Borg runs out of disk space, it tries to free as much space as it
 can while aborting the current operation safely, which allows the user to free more space
@@ -47,8 +47,7 @@ by deleting/pruning archives. This mechanism is not bullet-proof in some
 circumstances [1]_.
 
 If you *really* run out of disk space, it can be hard or impossible to free space,
-because Borg needs free space to operate - even to delete backup
-archives.
+because Borg needs free space to operate - even to delete backup archives.
 
 You can use some monitoring process or just include the free space information
 in your backup log files (you check them regularly anyway, right?).
@@ -185,7 +184,7 @@ backed up and that the ``prune`` command is keeping and deleting the correct bac
         --exclude 'home/*/.cache/*'     \
         --exclude 'var/tmp/*'           \
                                         \
-        ::'{hostname}-{now}'            \
+        '{hostname}-{now}'              \
         /etc                            \
         /home                           \
         /root                           \
@@ -315,30 +314,29 @@ You can use zstd for a wide range from high speed (and relatively low
 compression) using N=1 to high compression (and lower speed) using N=22.
 
 zstd is a modern compression algorithm and might be preferable over zlib and
-lzma, except if you need compatibility to older borg versions (< 1.1.4) that
-did not yet offer zstd.::
+lzma.::
 
-    $ borg create --compression zstd,N /path/to/repo::arch ~
+    $ borg create --compression zstd,N arch ~
 
 Other options are:
 
 If you have a fast repo storage and you want minimum CPU usage, no compression::
 
-    $ borg create --compression none /path/to/repo::arch ~
+    $ borg create --compression none arch ~
 
 If you have a less fast repo storage and you want a bit more compression (N=0..9,
 0 means no compression, 9 means high compression):
 
 ::
 
-    $ borg create --compression zlib,N /path/to/repo::arch ~
+    $ borg create --compression zlib,N arch ~
 
 If you have a very slow repo storage and you want high compression (N=0..9, 0 means
 low compression, 9 means high compression):
 
 ::
 
-    $ borg create --compression lzma,N /path/to/repo::arch ~
+    $ borg create --compression lzma,N arch ~
 
 You'll need to experiment a bit to find the best compression for your use case.
 Keep an eye on CPU load and throughput.
@@ -350,10 +348,10 @@ Repository encryption
 
 You can choose the repository encryption mode at repository creation time::
 
-    $ borg init --encryption=MODE PATH
+    $ borg rcreate --encryption=MODE
 
 For a list of available encryption MODEs and their descriptions, please refer
-to :ref:`borg_init`.
+to :ref:`borg_rcreate`.
 
 If you use encryption, all data is encrypted on the client before being written
 to the repository.
@@ -387,13 +385,6 @@ For automated backups the passphrase can be specified using the
     A backup inside of the backup that is encrypted with that key/passphrase
     won't help you with that, of course.
 
-    Only applies to repos using legacy encryption modes:
-    In case you lose your repository and the security information, but have an
-    older copy of it to restore from, don't use that later for creating new
-    backups – you would run into security issues (reuse of nonce counter
-    values). It is better to initialize a new Borg repository. See also:
-    :ref:`faq_corrupt_repo`
-
 .. _template: paperkey.html
 
 .. _remote_repos:
@@ -405,7 +396,7 @@ Borg can initialize and access repositories on remote hosts if the
 host is accessible using SSH.  This is fastest and easiest when Borg
 is installed on the remote host, in which case the following syntax is used::
 
-  $ borg init user@hostname:/path/to/repo
+  $ borg -r ssh://user@hostname:port/path/to/repo rcreate ...
 
 Note: please see the usage chapter for a full documentation of repo URLs.
 
@@ -421,7 +412,7 @@ it is still possible to use the remote host to store a repository by
 mounting the remote filesystem, for example, using sshfs::
 
   $ sshfs user@hostname:/path/to /path/to
-  $ borg init /path/to/repo
+  $ borg -r /path/to/repo rcreate ...
   $ fusermount -u /path/to
 
 You can also use other remote filesystems in a similar way. Just be careful,
@@ -517,13 +508,13 @@ Example with **borg mount**:
     # open a new, separate terminal (this terminal will be blocked until umount)
 
     # now we find out the archive names we have in the repo:
-    borg list /mnt/backup/borg_repo
+    borg rlist
 
     # mount one archive from a borg repo:
-    borg mount /mnt/backup/borg_repo::myserver-system-2019-08-11 /mnt/borg
+    borg mount -a myserver-system-2019-08-11 /mnt/borg
 
     # alternatively, mount all archives from a borg repo (slower):
-    borg mount /mnt/backup/borg_repo /mnt/borg
+    borg mount /mnt/borg
 
     # it may take a while until you will see stuff in /mnt/borg.
 
@@ -543,16 +534,16 @@ Example with **borg extract**:
     cd borg_restore
 
     # now we find out the archive names we have in the repo:
-    borg list /mnt/backup/borg_repo
+    borg rlist
 
     # we could find out the archive contents, esp. the path layout:
-    borg list /mnt/backup/borg_repo::myserver-system-2019-08-11
+    borg list myserver-system-2019-08-11
 
     # we extract only some specific path (note: no leading / !):
-    borg extract /mnt/backup/borg_repo::myserver-system-2019-08-11 path/to/extract
+    borg extract myserver-system-2019-08-11 path/to/extract
 
     # alternatively, we could fully extract the archive:
-    borg extract /mnt/backup/borg_repo::myserver-system-2019-08-11
+    borg extract myserver-system-2019-08-11
 
     # now move the files to the correct place...
 
@@ -574,6 +565,6 @@ case if unattended, automated backups were done).
 
 ::
 
-    borg mount ssh://borg@backup.example.org:2222/path/to/repo /mnt/borg
+    borg -r ssh://borg@backup.example.org:2222/path/to/repo mount /mnt/borg
     # or
-    borg extract ssh://borg@backup.example.org:2222/path/to/repo
+    borg -r ssh://borg@backup.example.org:2222/path/to/repo extract archive
diff --git a/docs/quickstart_example.rst.inc b/docs/quickstart_example.rst.inc
index abf1be6e0..2299483a1 100644
--- a/docs/quickstart_example.rst.inc
+++ b/docs/quickstart_example.rst.inc
@@ -1,62 +1,61 @@
 1. Before a backup can be made a repository has to be initialized::
 
-    $ borg init --encryption=repokey /path/to/repo
+    $ borg -r /path/to/repo rcreate --encryption=repokey-aes-ocb
 
 2. Backup the ``~/src`` and ``~/Documents`` directories into an archive called
    *Monday*::
 
-    $ borg create /path/to/repo::Monday ~/src ~/Documents
+    $ borg -r /path/to/repo create Monday ~/src ~/Documents
 
 3. The next day create a new archive called *Tuesday*::
 
-    $ borg create --stats /path/to/repo::Tuesday ~/src ~/Documents
+    $ borg -r /path/to/repo create --stats Tuesday ~/src ~/Documents
 
    This backup will be a lot quicker and a lot smaller since only new never
    before seen data is stored. The ``--stats`` option causes Borg to
-   output statistics about the newly created archive such as the amount of unique
-   data (not shared with other archives)::
+   output statistics about the newly created archive such as the deduplicated
+   size (the amount of unique data not shared with other archives)::
 
-    ------------------------------------------------------------------------------
+    Repository: /path/to/repo
     Archive name: Tuesday
-    Archive fingerprint: bd31004d58f51ea06ff735d2e5ac49376901b21d58035f8fb05dbf866566e3c2
-    Time (start): Tue, 2016-02-16 18:15:11
-    Time (end):   Tue, 2016-02-16 18:15:11
-
-    Duration: 0.19 seconds
-    Number of files: 127
-    ------------------------------------------------------------------------------
-                          Original size      Compressed size    Deduplicated size
-    This archive:                4.16 MB              4.17 MB             26.78 kB
-    All archives:                8.33 MB              8.34 MB              4.19 MB
-
-                          Unique chunks         Total chunks
-    Chunk index:                     132                  261
-    ------------------------------------------------------------------------------
+    Archive fingerprint: bcd1b53f9b4991b7afc2b339f851b7ffe3c6d030688936fe4552eccc1877718d
+    Time (start): Sat, 2022-06-25 20:21:43
+    Time (end):   Sat, 2022-06-25 20:21:43
+    Duration: 0.07 seconds
+    Utilization of max. archive size: 0%
+    Number of files: 699
+    Original size: 31.14 MB
+    Deduplicated size: 502 B
 
 4. List all archives in the repository::
 
-    $ borg list /path/to/repo
-    Monday                               Mon, 2016-02-15 19:14:44
-    Tuesday                              Tue, 2016-02-16 19:15:11
+    $ borg -r /path/to/repo rlist
+    Monday                               Sat, 2022-06-25 20:21:14 [b80e24d2...b179f298]
+    Tuesday                              Sat, 2022-06-25 20:21:43 [bcd1b53f...1877718d]
 
 5. List the contents of the *Monday* archive::
 
-    $ borg list /path/to/repo::Monday
+    $ borg -r /path/to/repo list Monday
     drwxr-xr-x user   group          0 Mon, 2016-02-15 18:22:30 home/user/Documents
     -rw-r--r-- user   group       7961 Mon, 2016-02-15 18:22:30 home/user/Documents/Important.doc
     ...
 
 6. Restore the *Monday* archive by extracting the files relative to the current directory::
 
-    $ borg extract /path/to/repo::Monday
+    $ borg -r /path/to/repo extract Monday
 
 7. Delete the *Monday* archive (please note that this does **not** free repo disk space)::
 
-    $ borg delete /path/to/repo::Monday
+    $ borg -r /path/to/repo delete -a Monday
+
+   Please note the ``-a`` option here (short for ``--glob-archives``) which enables you
+   to give a globbing pattern to delete multiple archives, like ``-a 'oldcrap-*'``.
+   You can also combine this with ``--first``, ``--last`` and ``--sort-by``.
+   Be careful, always first use with ``--dry-run`` and ``--list``!
 
 8. Recover disk space by compacting the segment files in the repo::
 
-    $ borg compact /path/to/repo
+    $ borg -r /path/to/repo compact
 
 .. Note::
     Borg is quiet by default (it works on WARNING log level).
diff --git a/docs/usage.rst b/docs/usage.rst
index f6e0113ee..3e649b71d 100644
--- a/docs/usage.rst
+++ b/docs/usage.rst
@@ -36,7 +36,16 @@ Usage
 .. toctree::
    usage/general
 
-   usage/init
+   usage/rcreate
+   usage/rlist
+   usage/rinfo
+   usage/rdelete
+   usage/serve
+   usage/compact
+   usage/config
+   usage/lock
+   usage/key
+
    usage/create
    usage/extract
    usage/check
@@ -45,16 +54,13 @@ Usage
    usage/diff
    usage/delete
    usage/prune
-   usage/compact
    usage/info
    usage/mount
-   usage/key
-   usage/upgrade
    usage/recreate
    usage/tar
-   usage/serve
-   usage/config
-   usage/lock
+
+   usage/transfer
+   usage/upgrade
    usage/benchmark
 
    usage/help
diff --git a/docs/usage/benchmark_cpu.rst.inc b/docs/usage/benchmark_cpu.rst.inc
index f02aeefd7..c52705cb0 100644
--- a/docs/usage/benchmark_cpu.rst.inc
+++ b/docs/usage/benchmark_cpu.rst.inc
@@ -40,5 +40,6 @@ This command benchmarks misc. CPU bound borg operations.
 
 It creates input data in memory, runs the operation and then displays throughput.
 To reduce outside influence on the timings, please make sure to run this with:
+
 - an otherwise as idle as possible machine
 - enough free memory so there will be no slow down due to paging activity
\ No newline at end of file
diff --git a/docs/usage/benchmark_crud.rst.inc b/docs/usage/benchmark_crud.rst.inc
index 3e67d7b6b..d8e41aba5 100644
--- a/docs/usage/benchmark_crud.rst.inc
+++ b/docs/usage/benchmark_crud.rst.inc
@@ -6,23 +6,21 @@ borg benchmark crud
 -------------------
 .. code-block:: none
 
-    borg [common options] benchmark crud [options] REPOSITORY PATH
+    borg [common options] benchmark crud [options] PATH
 
 .. only:: html
 
     .. class:: borg-options-table
 
-    +-------------------------------------------------------+----------------+----------------------------------------------+
-    | **positional arguments**                                                                                              |
-    +-------------------------------------------------------+----------------+----------------------------------------------+
-    |                                                       | ``REPOSITORY`` | repository to use for benchmark (must exist) |
-    +-------------------------------------------------------+----------------+----------------------------------------------+
-    |                                                       | ``PATH``       | path were to create benchmark input data     |
-    +-------------------------------------------------------+----------------+----------------------------------------------+
-    | .. class:: borg-common-opt-ref                                                                                        |
-    |                                                                                                                       |
-    | :ref:`common_options`                                                                                                 |
-    +-------------------------------------------------------+----------------+----------------------------------------------+
+    +-------------------------------------------------------+----------+------------------------------------------+
+    | **positional arguments**                                                                                    |
+    +-------------------------------------------------------+----------+------------------------------------------+
+    |                                                       | ``PATH`` | path were to create benchmark input data |
+    +-------------------------------------------------------+----------+------------------------------------------+
+    | .. class:: borg-common-opt-ref                                                                              |
+    |                                                                                                             |
+    | :ref:`common_options`                                                                                       |
+    +-------------------------------------------------------+----------+------------------------------------------+
 
     .. raw:: html
 
@@ -34,8 +32,6 @@ borg benchmark crud
 
 .. only:: latex
 
-    REPOSITORY
-        repository to use for benchmark (must exist)
     PATH
         path were to create benchmark input data
 
diff --git a/docs/usage/break-lock.rst.inc b/docs/usage/break-lock.rst.inc
index 17d5ce105..bdc47c539 100644
--- a/docs/usage/break-lock.rst.inc
+++ b/docs/usage/break-lock.rst.inc
@@ -6,21 +6,17 @@ borg break-lock
 ---------------
 .. code-block:: none
 
-    borg [common options] break-lock [options] [REPOSITORY]
+    borg [common options] break-lock [options]
 
 .. only:: html
 
     .. class:: borg-options-table
 
-    +-------------------------------------------------------+----------------+-----------------------------------------+
-    | **positional arguments**                                                                                         |
-    +-------------------------------------------------------+----------------+-----------------------------------------+
-    |                                                       | ``REPOSITORY`` | repository for which to break the locks |
-    +-------------------------------------------------------+----------------+-----------------------------------------+
-    | .. class:: borg-common-opt-ref                                                                                   |
-    |                                                                                                                  |
-    | :ref:`common_options`                                                                                            |
-    +-------------------------------------------------------+----------------+-----------------------------------------+
+    +-------------------------------------------------------+
+    | .. class:: borg-common-opt-ref                        |
+    |                                                       |
+    | :ref:`common_options`                                 |
+    +-------------------------------------------------------+
 
     .. raw:: html
 
@@ -32,8 +28,6 @@ borg break-lock
 
 .. only:: latex
 
-    REPOSITORY
-        repository for which to break the locks
 
 
     :ref:`common_options`
diff --git a/docs/usage/check.rst.inc b/docs/usage/check.rst.inc
index 0f4ff7afb..948f4d63b 100644
--- a/docs/usage/check.rst.inc
+++ b/docs/usage/check.rst.inc
@@ -6,19 +6,17 @@ borg check
 ----------
 .. code-block:: none
 
-    borg [common options] check [options] [REPOSITORY_OR_ARCHIVE]
+    borg [common options] check [options]
 
 .. only:: html
 
     .. class:: borg-options-table
 
-    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------+
-    | **positional arguments**                                                                                                                                                                                                                                                     |
-    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------+
-    |                                                                             | ``REPOSITORY_OR_ARCHIVE``             | repository or archive to check consistency of                                                                                                          |
     +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------+
     | **optional arguments**                                                                                                                                                                                                                                                       |
     +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------+
+    |                                                                             | ``--name NAME``                       | specify the archive name                                                                                                                               |
+    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------+
     |                                                                             | ``--repository-only``                 | only perform repository checks                                                                                                                         |
     +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------+
     |                                                                             | ``--archives-only``                   | only perform archives checks                                                                                                                           |
@@ -58,11 +56,10 @@ borg check
 
 .. only:: latex
 
-    REPOSITORY_OR_ARCHIVE
-        repository or archive to check consistency of
 
 
     optional arguments
+        --name NAME       specify the archive name
         --repository-only    only perform repository checks
         --archives-only    only perform archives checks
         --verify-data     perform cryptographic archive data integrity verification (conflicts with ``--repository-only``)
diff --git a/docs/usage/common-options.rst.inc b/docs/usage/common-options.rst.inc
index f31f0fd49..d091d9b98 100644
--- a/docs/usage/common-options.rst.inc
+++ b/docs/usage/common-options.rst.inc
@@ -1,23 +1,24 @@
--h, --help         show this help message and exit
---critical         work on log level CRITICAL
---error            work on log level ERROR
---warning          work on log level WARNING (default)
+-h, --help               show this help message and exit
+--critical               work on log level CRITICAL
+--error                  work on log level ERROR
+--warning                work on log level WARNING (default)
 --info, -v, --verbose    work on log level INFO
---debug            enable debug output, work on log level DEBUG
---debug-topic TOPIC    enable TOPIC debugging (can be specified multiple times). The logger path is borg.debug.<TOPIC> if TOPIC is not fully qualified.
--p, --progress     show progress information
---iec              format using IEC units (1KiB = 1024B)
---log-json         Output one JSON object per log line instead of formatted text.
---lock-wait SECONDS    wait at most SECONDS for acquiring a repository/cache lock (default: 1).
---bypass-lock      Bypass locking mechanism
---show-version     show/log the borg version
---show-rc          show/log the return code (rc)
---umask M          set umask to M (local only, default: 0077)
---remote-path PATH    use PATH as borg executable on the remote (default: "borg")
+--debug                  enable debug output, work on log level DEBUG
+--debug-topic TOPIC      enable TOPIC debugging (can be specified multiple times). The logger path is borg.debug.<TOPIC> if TOPIC is not fully qualified.
+-p, --progress           show progress information
+--iec                    format using IEC units (1KiB = 1024B)
+--log-json               Output one JSON object per log line instead of formatted text.
+--lock-wait SECONDS      wait at most SECONDS for acquiring a repository/cache lock (default: 1).
+--bypass-lock            Bypass locking mechanism
+--show-version           show/log the borg version
+--show-rc                show/log the return code (rc)
+--umask M                set umask to M (local only, default: 0077)
+--remote-path PATH       use PATH as borg executable on the remote (default: "borg")
 --remote-ratelimit RATE    deprecated, use ``--upload-ratelimit`` instead
 --upload-ratelimit RATE    set network upload rate limit in kiByte/s (default: 0=unlimited)
 --remote-buffer UPLOAD_BUFFER    deprecated, use ``--upload-buffer`` instead
 --upload-buffer UPLOAD_BUFFER    set network upload buffer size in MiB. (default: 0=no buffer)
 --consider-part-files    treat part files like normal files (e.g. to list/extract them)
---debug-profile FILE    Write execution profile in Borg format into FILE. For local use a Python-compatible file can be generated by suffixing FILE with ".pyprof".
---rsh RSH          Use this command to connect to the 'borg serve' process (default: 'ssh')
+--debug-profile FILE     Write execution profile in Borg format into FILE. For local use a Python-compatible file can be generated by suffixing FILE with ".pyprof".
+--rsh RSH                Use this command to connect to the 'borg serve' process (default: 'ssh')
+-r REPO, --repo REPO     repository to use
diff --git a/docs/usage/compact.rst b/docs/usage/compact.rst
index 2633d29eb..6a3a15ad0 100644
--- a/docs/usage/compact.rst
+++ b/docs/usage/compact.rst
@@ -5,9 +5,4 @@ Examples
 ::
 
     # compact segments and free repo disk space
-    $ borg compact /path/to/repo
-
-    # same as above plus clean up 17byte commit-only segments
-    $ borg compact --cleanup-commits /path/to/repo
-
-
+    $ borg compact
diff --git a/docs/usage/compact.rst.inc b/docs/usage/compact.rst.inc
index 8187bbf7f..d9614fb4a 100644
--- a/docs/usage/compact.rst.inc
+++ b/docs/usage/compact.rst.inc
@@ -6,16 +6,12 @@ borg compact
 ------------
 .. code-block:: none
 
-    borg [common options] compact [options] [REPOSITORY]
+    borg [common options] compact [options]
 
 .. only:: html
 
     .. class:: borg-options-table
 
-    +-------------------------------------------------------+-------------------------+----------------------------------------------------------------+
-    | **positional arguments**                                                                                                                         |
-    +-------------------------------------------------------+-------------------------+----------------------------------------------------------------+
-    |                                                       | ``REPOSITORY``          | repository to compact                                          |
     +-------------------------------------------------------+-------------------------+----------------------------------------------------------------+
     | **optional arguments**                                                                                                                           |
     +-------------------------------------------------------+-------------------------+----------------------------------------------------------------+
@@ -38,8 +34,6 @@ borg compact
 
 .. only:: latex
 
-    REPOSITORY
-        repository to compact
 
 
     optional arguments
diff --git a/docs/usage/config.rst b/docs/usage/config.rst
index dc21eb39d..f06d75298 100644
--- a/docs/usage/config.rst
+++ b/docs/usage/config.rst
@@ -11,12 +11,12 @@ Examples
 ::
 
     # find cache directory
-    $ cd ~/.cache/borg/$(borg config /path/to/repo id)
+    $ cd ~/.cache/borg/$(borg config id)
 
     # reserve some space
-    $ borg config /path/to/repo additional_free_space 2G
+    $ borg config additional_free_space 2G
 
     # make a repo append-only
-    $ borg config /path/to/repo append_only 1
+    $ borg config append_only 1
 
 
diff --git a/docs/usage/config.rst.inc b/docs/usage/config.rst.inc
index d90c327ee..d0d2e9e7b 100644
--- a/docs/usage/config.rst.inc
+++ b/docs/usage/config.rst.inc
@@ -6,7 +6,7 @@ borg config
 -----------
 .. code-block:: none
 
-    borg [common options] config [options] [REPOSITORY] [NAME] [VALUE]
+    borg [common options] config [options] [NAME] [VALUE]
 
 .. only:: html
 
@@ -15,8 +15,6 @@ borg config
     +-------------------------------------------------------+----------------------+----------------------------------------+
     | **positional arguments**                                                                                              |
     +-------------------------------------------------------+----------------------+----------------------------------------+
-    |                                                       | ``REPOSITORY``       | repository to configure                |
-    +-------------------------------------------------------+----------------------+----------------------------------------+
     |                                                       | ``NAME``             | name of config key                     |
     +-------------------------------------------------------+----------------------+----------------------------------------+
     |                                                       | ``VALUE``            | new value for key                      |
@@ -44,8 +42,6 @@ borg config
 
 .. only:: latex
 
-    REPOSITORY
-        repository to configure
     NAME
         name of config key
     VALUE
diff --git a/docs/usage/create.rst b/docs/usage/create.rst
index 16906d7ee..9d88b5469 100644
--- a/docs/usage/create.rst
+++ b/docs/usage/create.rst
@@ -5,83 +5,81 @@ Examples
 ::
 
     # Backup ~/Documents into an archive named "my-documents"
-    $ borg create /path/to/repo::my-documents ~/Documents
+    $ borg create my-documents ~/Documents
 
     # same, but list all files as we process them
-    $ borg create --list /path/to/repo::my-documents ~/Documents
+    $ borg create --list my-documents ~/Documents
 
     # Backup ~/Documents and ~/src but exclude pyc files
-    $ borg create /path/to/repo::my-files \
+    $ borg create my-files                \
         ~/Documents                       \
         ~/src                             \
         --exclude '*.pyc'
 
     # Backup home directories excluding image thumbnails (i.e. only
     # /home/<one directory>/.thumbnails is excluded, not /home/*/*/.thumbnails etc.)
-    $ borg create /path/to/repo::my-files /home \
-        --exclude 'sh:home/*/.thumbnails'
+    $ borg create my-files /home --exclude 'sh:home/*/.thumbnails'
 
     # Backup the root filesystem into an archive named "root-YYYY-MM-DD"
     # use zlib compression (good, but slow) - default is lz4 (fast, low compression ratio)
-    $ borg create -C zlib,6 --one-file-system /path/to/repo::root-{now:%Y-%m-%d} /
+    $ borg create -C zlib,6 --one-file-system root-{now:%Y-%m-%d} /
 
-    # Backup onto a remote host ("push" style) via ssh to port 2222,
-    # logging in as user "borg" and storing into /path/to/repo
-    $ borg create ssh://borg@backup.example.org:2222/path/to/repo::{fqdn}-root-{now} /
+    # Backup into an archive name like FQDN-root-TIMESTAMP
+    $ borg create '{fqdn}-root-{now}' /
 
     # Backup a remote host locally ("pull" style) using sshfs
     $ mkdir sshfs-mount
     $ sshfs root@example.com:/ sshfs-mount
     $ cd sshfs-mount
-    $ borg create /path/to/repo::example.com-root-{now:%Y-%m-%d} .
+    $ borg create example.com-root-{now:%Y-%m-%d} .
     $ cd ..
     $ fusermount -u sshfs-mount
 
     # Make a big effort in fine granular deduplication (big chunk management
     # overhead, needs a lot of RAM and disk space, see formula in internals
     # docs - same parameters as borg < 1.0 or attic):
-    $ borg create --chunker-params buzhash,10,23,16,4095 /path/to/repo::small /smallstuff
+    $ borg create --chunker-params buzhash,10,23,16,4095 small /smallstuff
 
     # Backup a raw device (must not be active/in use/mounted at that time)
-    $ borg create --read-special --chunker-params fixed,4194304 /path/to/repo::my-sdx /dev/sdX
+    $ borg create --read-special --chunker-params fixed,4194304 my-sdx /dev/sdX
 
     # Backup a sparse disk image (must not be active/in use/mounted at that time)
-    $ borg create --sparse --chunker-params fixed,4194304 /path/to/repo::my-disk my-disk.raw
+    $ borg create --sparse --chunker-params fixed,4194304 my-disk my-disk.raw
 
     # No compression (none)
-    $ borg create --compression none /path/to/repo::arch ~
+    $ borg create --compression none arch ~
 
     # Super fast, low compression (lz4, default)
-    $ borg create /path/to/repo::arch ~
+    $ borg create arch ~
 
     # Less fast, higher compression (zlib, N = 0..9)
-    $ borg create --compression zlib,N /path/to/repo::arch ~
+    $ borg create --compression zlib,N arch ~
 
     # Even slower, even higher compression (lzma, N = 0..9)
-    $ borg create --compression lzma,N /path/to/repo::arch ~
+    $ borg create --compression lzma,N arch ~
 
     # Only compress compressible data with lzma,N (N = 0..9)
-    $ borg create --compression auto,lzma,N /path/to/repo::arch ~
+    $ borg create --compression auto,lzma,N arch ~
 
     # Use short hostname, user name and current time in archive name
-    $ borg create /path/to/repo::{hostname}-{user}-{now} ~
+    $ borg create '{hostname}-{user}-{now}' ~
     # Similar, use the same datetime format that is default as of borg 1.1
-    $ borg create /path/to/repo::{hostname}-{user}-{now:%Y-%m-%dT%H:%M:%S} ~
+    $ borg create '{hostname}-{user}-{now:%Y-%m-%dT%H:%M:%S}' ~
     # As above, but add nanoseconds
-    $ borg create /path/to/repo::{hostname}-{user}-{now:%Y-%m-%dT%H:%M:%S.%f} ~
+    $ borg create '{hostname}-{user}-{now:%Y-%m-%dT%H:%M:%S.%f}' ~
 
     # Backing up relative paths by moving into the correct directory first
     $ cd /home/user/Documents
     # The root directory of the archive will be "projectA"
-    $ borg create /path/to/repo::daily-projectA-{now:%Y-%m-%d} projectA
+    $ borg create 'daily-projectA-{now:%Y-%m-%d}' projectA
 
     # Use external command to determine files to archive
     # Use --paths-from-stdin with find to only backup files less than 1MB in size
-    $ find ~ -size -1000k | borg create --paths-from-stdin /path/to/repo::small-files-only
+    $ find ~ -size -1000k | borg create --paths-from-stdin small-files-only
     # Use --paths-from-command with find to only backup files from a given user
-    $ borg create --paths-from-command /path/to/repo::joes-files -- find /srv/samba/shared -user joe
+    $ borg create --paths-from-command joes-files -- find /srv/samba/shared -user joe
     # Use --paths-from-stdin with --paths-delimiter (for example, for filenames with newlines in them)
     $ find ~ -size -1000k -print0 | borg create \
         --paths-from-stdin \
         --paths-delimiter "\0" \
-        /path/to/repo::smallfiles-handle-newline
+        smallfiles-handle-newline
diff --git a/docs/usage/create.rst.inc b/docs/usage/create.rst.inc
index b61fb9794..9fa36fc86 100644
--- a/docs/usage/create.rst.inc
+++ b/docs/usage/create.rst.inc
@@ -6,7 +6,7 @@ borg create
 -----------
 .. code-block:: none
 
-    borg [common options] create [options] ARCHIVE [PATH...]
+    borg [common options] create [options] NAME [PATH...]
 
 .. only:: html
 
@@ -15,7 +15,7 @@ borg create
     +-------------------------------------------------------+---------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------+
     | **positional arguments**                                                                                                                                                                                                                                         |
     +-------------------------------------------------------+---------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------+
-    |                                                       | ``ARCHIVE``                                       | name of archive to create (must be also a valid directory name)                                                                                      |
+    |                                                       | ``NAME``                                          | specify the archive name                                                                                                                             |
     +-------------------------------------------------------+---------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------+
     |                                                       | ``PATH``                                          | paths to archive                                                                                                                                     |
     +-------------------------------------------------------+---------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------+
@@ -37,7 +37,7 @@ borg create
     +-------------------------------------------------------+---------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------+
     |                                                       | ``--stdin-user USER``                             | set user USER in archive for stdin data (default: 'root')                                                                                            |
     +-------------------------------------------------------+---------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------+
-    |                                                       | ``--stdin-group GROUP``                           | set group GROUP in archive for stdin data (default: 'root')                                                                                          |
+    |                                                       | ``--stdin-group GROUP``                           | set group GROUP in archive for stdin data (default: 'wheel')                                                                                         |
     +-------------------------------------------------------+---------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------+
     |                                                       | ``--stdin-mode M``                                | set mode to M in archive for stdin data (default: 0660)                                                                                              |
     +-------------------------------------------------------+---------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------+
@@ -124,8 +124,8 @@ borg create
 
 .. only:: latex
 
-    ARCHIVE
-        name of archive to create (must be also a valid directory name)
+    NAME
+        specify the archive name
     PATH
         paths to archive
 
@@ -139,7 +139,7 @@ borg create
         --no-cache-sync    experimental: do not synchronize the cache. Implies not using the files cache.
         --stdin-name NAME    use NAME in archive for stdin data (default: 'stdin')
         --stdin-user USER    set user USER in archive for stdin data (default: 'root')
-        --stdin-group GROUP    set group GROUP in archive for stdin data (default: 'root')
+        --stdin-group GROUP    set group GROUP in archive for stdin data (default: 'wheel')
         --stdin-mode M    set mode to M in archive for stdin data (default: 0660)
         --content-from-command    interpret PATH as command and store its stdout. See also section Reading from stdin below.
         --paths-from-stdin    read DELIM-separated list of paths to backup from stdin. Will not recurse into directories.
diff --git a/docs/usage/delete.rst b/docs/usage/delete.rst
index 7bd50b5dd..d3f44a066 100644
--- a/docs/usage/delete.rst
+++ b/docs/usage/delete.rst
@@ -5,23 +5,15 @@ Examples
 ::
 
     # delete a single backup archive:
-    $ borg delete /path/to/repo::Monday
+    $ borg delete Monday
     # actually free disk space:
-    $ borg compact /path/to/repo
+    $ borg compact
 
     # delete all archives whose names begin with the machine's hostname followed by "-"
-    $ borg delete --prefix '{hostname}-' /path/to/repo
+    $ borg delete --prefix '{hostname}-'
 
     # delete all archives whose names contain "-2012-"
-    $ borg delete --glob-archives '*-2012-*' /path/to/repo
+    $ borg delete -a '*-2012-*'
 
     # see what would be deleted if delete was run without --dry-run
-    $ borg delete --list --dry-run -a '*-May-*' /path/to/repo
-
-    # delete the whole repository and the related local cache:
-    $ borg delete /path/to/repo
-    You requested to completely DELETE the repository *including* all archives it contains:
-    repo                                 Mon, 2016-02-15 19:26:54
-    root-2016-02-15                      Mon, 2016-02-15 19:36:29
-    newname                              Mon, 2016-02-15 19:50:19
-    Type 'YES' if you understand this and want to continue: YES
+    $ borg delete --list --dry-run -a '*-May-*'
diff --git a/docs/usage/delete.rst.inc b/docs/usage/delete.rst.inc
index 0cf94191f..1fd9ba8e9 100644
--- a/docs/usage/delete.rst.inc
+++ b/docs/usage/delete.rst.inc
@@ -6,18 +6,12 @@ borg delete
 -----------
 .. code-block:: none
 
-    borg [common options] delete [options] [REPOSITORY_OR_ARCHIVE] [ARCHIVE...]
+    borg [common options] delete [options]
 
 .. only:: html
 
     .. class:: borg-options-table
 
-    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------+
-    | **positional arguments**                                                                                                                                                                                                                                                     |
-    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------+
-    |                                                                             | ``REPOSITORY_OR_ARCHIVE``             | repository or archive to delete                                                                                                                        |
-    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------+
-    |                                                                             | ``ARCHIVE``                           | archives to delete                                                                                                                                     |
     +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------+
     | **optional arguments**                                                                                                                                                                                                                                                       |
     +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------+
@@ -25,6 +19,8 @@ borg delete
     +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------+
     |                                                                             | ``--list``                            | output verbose list of archives                                                                                                                        |
     +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------+
+    |                                                                             | ``--consider-checkpoints``            | consider checkpoint archives for deletion (default: not considered).                                                                                   |
+    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------+
     |                                                                             | ``-s``, ``--stats``                   | print statistics for the deleted archive                                                                                                               |
     +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------+
     |                                                                             | ``--cache-only``                      | delete only the local cache for the given repository                                                                                                   |
@@ -62,15 +58,12 @@ borg delete
 
 .. only:: latex
 
-    REPOSITORY_OR_ARCHIVE
-        repository or archive to delete
-    ARCHIVE
-        archives to delete
 
 
     optional arguments
         -n, --dry-run    do not change repository
         --list          output verbose list of archives
+        --consider-checkpoints    consider checkpoint archives for deletion (default: not considered).
         -s, --stats     print statistics for the deleted archive
         --cache-only    delete only the local cache for the given repository
         --force         force deletion of corrupted archives, use ``--force --force`` in case ``--force`` does not work.
@@ -92,16 +85,11 @@ borg delete
 Description
 ~~~~~~~~~~~
 
-This command deletes an archive from the repository or the complete repository.
+This command deletes archives from the repository.
 
 Important: When deleting archives, repository disk space is **not** freed until
 you run ``borg compact``.
 
-When you delete a complete repository, the security info and local cache for it
-(if any) are also deleted. Alternatively, you can delete just the local cache
-with the ``--cache-only`` option, or keep the security info with the
-``--keep-security-info`` option.
-
 When in doubt, use ``--dry-run --list`` to see what would be deleted.
 
 When using ``--stats``, you will get some statistics about how much data was
@@ -115,6 +103,4 @@ pattern to match multiple archives using the ``--glob-archives GLOB`` option
 (for more info on these patterns, see :ref:`borg_patterns`). Note that these
 two options are mutually exclusive.
 
-To avoid accidentally deleting archives, especially when using glob patterns,
-it might be helpful to use the ``--dry-run`` to test out the command without
-actually making any changes to the repository.
\ No newline at end of file
+Always first use ``--dry-run --list`` to see what would be deleted.
\ No newline at end of file
diff --git a/docs/usage/diff.rst b/docs/usage/diff.rst
index d9542a737..c758aceff 100644
--- a/docs/usage/diff.rst
+++ b/docs/usage/diff.rst
@@ -4,41 +4,14 @@ Examples
 ~~~~~~~~
 ::
 
-    $ borg init -e=none testrepo
-    $ mkdir testdir
-    $ cd testdir
-    $ echo asdf > file1
-    $ dd if=/dev/urandom bs=1M count=4 > file2
-    $ touch file3
-    $ borg create ../testrepo::archive1 .
-
-    $ chmod a+x file1
-    $ echo "something" >> file2
-    $ borg create ../testrepo::archive2 .
-
-    $ echo "testing 123" >> file1
-    $ rm file3
-    $ touch file4
-    $ borg create ../testrepo::archive3 .
-
-    $ cd ..
-    $ borg diff testrepo::archive1 archive2
-    [-rw-r--r-- -> -rwxr-xr-x] file1
-       +135 B    -252 B file2
-
-    $ borg diff testrepo::archive2 archive3
-        +17 B      -5 B file1
-    added           0 B file4
-    removed         0 B file3
-
-    $ borg diff testrepo::archive1 archive3
+    $ borg diff archive1 archive2
         +17 B      -5 B [-rw-r--r-- -> -rwxr-xr-x] file1
        +135 B    -252 B file2
     added           0 B file4
     removed         0 B file3
 
-    $ borg diff --json-lines testrepo::archive1 archive3
+    $ borg diff archive1 archive2
     {"path": "file1", "changes": [{"type": "modified", "added": 17, "removed": 5}, {"type": "mode", "old_mode": "-rw-r--r--", "new_mode": "-rwxr-xr-x"}]}
     {"path": "file2", "changes": [{"type": "modified", "added": 135, "removed": 252}]}
     {"path": "file4", "changes": [{"type": "added", "size": 0}]}
-    {"path": "file3", "changes": [{"type": "removed", "size": 0}]}
\ No newline at end of file
+    {"path": "file3", "changes": [{"type": "removed", "size": 0}]}
diff --git a/docs/usage/diff.rst.inc b/docs/usage/diff.rst.inc
index 267aad605..11d97fbfb 100644
--- a/docs/usage/diff.rst.inc
+++ b/docs/usage/diff.rst.inc
@@ -6,7 +6,7 @@ borg diff
 ---------
 .. code-block:: none
 
-    borg [common options] diff [options] REPO::ARCHIVE1 ARCHIVE2 [PATH...]
+    borg [common options] diff [options] ARCHIVE1 ARCHIVE2 [PATH...]
 
 .. only:: html
 
@@ -15,9 +15,9 @@ borg diff
     +-------------------------------------------------------+---------------------------------------+-----------------------------------------------------------------------+
     | **positional arguments**                                                                                                                                              |
     +-------------------------------------------------------+---------------------------------------+-----------------------------------------------------------------------+
-    |                                                       | ``REPO::ARCHIVE1``                    | repository location and ARCHIVE1 name                                 |
+    |                                                       | ``ARCHIVE1``                          | ARCHIVE1 name                                                         |
     +-------------------------------------------------------+---------------------------------------+-----------------------------------------------------------------------+
-    |                                                       | ``ARCHIVE2``                          | ARCHIVE2 name (no repository location allowed)                        |
+    |                                                       | ``ARCHIVE2``                          | ARCHIVE2 name                                                         |
     +-------------------------------------------------------+---------------------------------------+-----------------------------------------------------------------------+
     |                                                       | ``PATH``                              | paths of items inside the archives to compare; patterns are supported |
     +-------------------------------------------------------+---------------------------------------+-----------------------------------------------------------------------+
@@ -58,10 +58,10 @@ borg diff
 
 .. only:: latex
 
-    REPO::ARCHIVE1
-        repository location and ARCHIVE1 name
+    ARCHIVE1
+        ARCHIVE1 name
     ARCHIVE2
-        ARCHIVE2 name (no repository location allowed)
+        ARCHIVE2 name
     PATH
         paths of items inside the archives to compare; patterns are supported
 
diff --git a/docs/usage/export-tar.rst.inc b/docs/usage/export-tar.rst.inc
index ea7a20b8c..5839bb2f6 100644
--- a/docs/usage/export-tar.rst.inc
+++ b/docs/usage/export-tar.rst.inc
@@ -6,7 +6,7 @@ borg export-tar
 ---------------
 .. code-block:: none
 
-    borg [common options] export-tar [options] ARCHIVE FILE [PATH...]
+    borg [common options] export-tar [options] NAME FILE [PATH...]
 
 .. only:: html
 
@@ -15,7 +15,7 @@ borg export-tar
     +-------------------------------------------------------+---------------------------------------+-----------------------------------------------------------------------------------------------------------+
     | **positional arguments**                                                                                                                                                                                  |
     +-------------------------------------------------------+---------------------------------------+-----------------------------------------------------------------------------------------------------------+
-    |                                                       | ``ARCHIVE``                           | archive to export                                                                                         |
+    |                                                       | ``NAME``                              | specify the archive name                                                                                  |
     +-------------------------------------------------------+---------------------------------------+-----------------------------------------------------------------------------------------------------------+
     |                                                       | ``FILE``                              | output tar file. "-" to write to stdout instead.                                                          |
     +-------------------------------------------------------+---------------------------------------+-----------------------------------------------------------------------------------------------------------+
@@ -56,8 +56,8 @@ borg export-tar
 
 .. only:: latex
 
-    ARCHIVE
-        archive to export
+    NAME
+        specify the archive name
     FILE
         output tar file. "-" to write to stdout instead.
     PATH
diff --git a/docs/usage/extract.rst b/docs/usage/extract.rst
index 292f84bdc..1d53fb338 100644
--- a/docs/usage/extract.rst
+++ b/docs/usage/extract.rst
@@ -5,19 +5,19 @@ Examples
 ::
 
     # Extract entire archive
-    $ borg extract /path/to/repo::my-files
+    $ borg extract my-files
 
     # Extract entire archive and list files while processing
-    $ borg extract --list /path/to/repo::my-files
+    $ borg extract --list my-files
 
     # Verify whether an archive could be successfully extracted, but do not write files to disk
-    $ borg extract --dry-run /path/to/repo::my-files
+    $ borg extract --dry-run my-files
 
     # Extract the "src" directory
-    $ borg extract /path/to/repo::my-files home/USERNAME/src
+    $ borg extract my-files home/USERNAME/src
 
     # Extract the "src" directory but exclude object files
-    $ borg extract /path/to/repo::my-files home/USERNAME/src --exclude '*.o'
+    $ borg extract my-files home/USERNAME/src --exclude '*.o'
 
     # Restore a raw device (must not be active/in use/mounted at that time)
-    $ borg extract --stdout /path/to/repo::my-sdx | dd of=/dev/sdx bs=10M
+    $ borg extract --stdout my-sdx | dd of=/dev/sdx bs=10M
diff --git a/docs/usage/extract.rst.inc b/docs/usage/extract.rst.inc
index c157c768a..9bd53bc94 100644
--- a/docs/usage/extract.rst.inc
+++ b/docs/usage/extract.rst.inc
@@ -6,7 +6,7 @@ borg extract
 ------------
 .. code-block:: none
 
-    borg [common options] extract [options] ARCHIVE [PATH...]
+    borg [common options] extract [options] NAME [PATH...]
 
 .. only:: html
 
@@ -15,7 +15,7 @@ borg extract
     +-------------------------------------------------------+---------------------------------------+-----------------------------------------------------------------------------------------------------------+
     | **positional arguments**                                                                                                                                                                                  |
     +-------------------------------------------------------+---------------------------------------+-----------------------------------------------------------------------------------------------------------+
-    |                                                       | ``ARCHIVE``                           | archive to extract                                                                                        |
+    |                                                       | ``NAME``                              | specify the archive name                                                                                  |
     +-------------------------------------------------------+---------------------------------------+-----------------------------------------------------------------------------------------------------------+
     |                                                       | ``PATH``                              | paths to extract; patterns are supported                                                                  |
     +-------------------------------------------------------+---------------------------------------+-----------------------------------------------------------------------------------------------------------+
@@ -68,8 +68,8 @@ borg extract
 
 .. only:: latex
 
-    ARCHIVE
-        archive to extract
+    NAME
+        specify the archive name
     PATH
         paths to extract; patterns are supported
 
diff --git a/docs/usage/general.rst b/docs/usage/general.rst
index 677678a1d..16be87f62 100644
--- a/docs/usage/general.rst
+++ b/docs/usage/general.rst
@@ -7,7 +7,7 @@ The following sections will describe each command in detail.
 
 Commands, options, parameters, paths and such are ``set in fixed-width``.
 Option values are `underlined`. Borg has few options accepting a fixed set
-of values (e.g. ``--encryption`` of :ref:`borg_init`).
+of values (e.g. ``--encryption`` of :ref:`borg_rcreate`).
 
 .. container:: experimental
 
@@ -54,5 +54,5 @@ Examples
 ::
 
     # Create an archive and log: borg version, files list, return code
-    $ borg create --show-version --list --show-rc /path/to/repo::my-files files
+    $ borg -r /path/to/repo create --show-version --list --show-rc my-files files
 
diff --git a/docs/usage/general/environment.rst.inc b/docs/usage/general/environment.rst.inc
index ca6ecc6b9..bdec4219f 100644
--- a/docs/usage/general/environment.rst.inc
+++ b/docs/usage/general/environment.rst.inc
@@ -5,9 +5,10 @@ Borg uses some environment variables for automation:
 
 General:
     BORG_REPO
-        When set, use the value to give the default repository location. If a command needs an archive
-        parameter, you can abbreviate as ``::archive``. If a command needs a repository parameter, you
-        can either leave it away or abbreviate as ``::``, if a positional parameter is required.
+        When set, use the value to give the default repository location.
+        Use this so you do not need to type ``--repo /path/to/my/repo`` all the time.
+    BORG_OTHER_REPO
+        Similar to BORG_REPO, but gives the default for ``--other-repo``.
     BORG_PASSPHRASE
         When set, use the value to answer the passphrase question for encrypted repositories.
         It is used when a passphrase is needed to access an encrypted repo as well as when a new
diff --git a/docs/usage/general/positional-arguments.rst.inc b/docs/usage/general/positional-arguments.rst.inc
index 718bd08be..f397237ee 100644
--- a/docs/usage/general/positional-arguments.rst.inc
+++ b/docs/usage/general/positional-arguments.rst.inc
@@ -7,9 +7,9 @@ in the example), but not in between them:
 
 ::
 
-    borg create -s --progress repo::archive path  # good and preferred
-    borg create repo::archive path -s --progress  # also works
-    borg create -s repo::archive path --progress  # works, but ugly
-    borg create repo::archive -s --progress path  # BAD
+    borg create -s --progress archive path  # good and preferred
+    borg create archive path -s --progress  # also works
+    borg create -s archive path --progress  # works, but ugly
+    borg create archive -s --progress path  # BAD
 
 This is due to a problem in the argparse module: https://bugs.python.org/issue15112
diff --git a/docs/usage/general/repository-locations.rst.inc b/docs/usage/general/repository-locations.rst.inc
index 06799d7bb..b8baa62c3 100644
--- a/docs/usage/general/repository-locations.rst.inc
+++ b/docs/usage/general/repository-locations.rst.inc
@@ -1,13 +1,14 @@
-Repository / Archive Locations
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+Repository Locations / Archive names
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-Many commands want either a repository (just give the repo URL, see above) or
-an archive location, which is a repo URL followed by ``::archive_name``.
+Many commands need to know the repository location, give it via ``-r`` / ``--repo``
+or use the ``BORG_REPO`` environment variable.
+
+Commands needing one or two archive names usually get them as positional argument.
+
+Commands working with an arbitrary amount of archives, usually take ``-a ARCH_GLOB``.
 
 Archive names must not contain the ``/`` (slash) character. For simplicity,
 maybe also avoid blanks or other characters that have special meaning on the
 shell or in a filesystem (borg mount will use the archive name as directory
 name).
-
-If you have set BORG_REPO (see above) and an archive location is needed, use
-``::archive_name`` - the repo URL part is then read from BORG_REPO.
diff --git a/docs/usage/general/repository-urls.rst.inc b/docs/usage/general/repository-urls.rst.inc
index 2855c19b2..7bca942d3 100644
--- a/docs/usage/general/repository-urls.rst.inc
+++ b/docs/usage/general/repository-urls.rst.inc
@@ -14,24 +14,7 @@ Note: you may also prepend a ``file://`` to a filesystem path to get URL style.
 
 **Remote repositories** accessed via ssh user@host:
 
-``user@host:/path/to/repo`` - remote repo, absolute path
-
-``ssh://user@host:port/path/to/repo`` - same, alternative syntax, port can be given
-
-
-**Remote repositories with relative paths** can be given using this syntax:
-
-``user@host:path/to/repo`` - path relative to current directory
-
-``user@host:~/path/to/repo`` - path relative to user's home directory
-
-``user@host:~other/path/to/repo`` - path relative to other's home directory
-
-Note: giving ``user@host:/./path/to/repo`` or ``user@host:/~/path/to/repo`` or
-``user@host:/~other/path/to/repo`` is also supported, but not required here.
-
-
-**Remote repositories with relative paths, alternative syntax with port**:
+``ssh://user@host:port/path/to/repo`` - absolute path`
 
 ``ssh://user@host:port/./path/to/repo`` - path relative to current directory
 
@@ -47,8 +30,5 @@ If you frequently need the same repo URL, it is a good idea to set the
 
     export BORG_REPO='ssh://user@host:port/path/to/repo'
 
-Then just leave away the repo URL if only a repo URL is needed and you want
+Then just leave away the ``--repo`` option if you want
 to use the default - it will be read from BORG_REPO then.
-
-Use ``::`` syntax to give the repo URL when syntax requires giving a positional
-argument for the repo (e.g. ``borg mount :: /mnt``).
diff --git a/docs/usage/help.rst.inc b/docs/usage/help.rst.inc
index 7f9b4e9e0..a4c4c975f 100644
--- a/docs/usage/help.rst.inc
+++ b/docs/usage/help.rst.inc
@@ -6,42 +6,35 @@ borg help patterns
 ~~~~~~~~~~~~~~~~~~
 
 
-The path/filenames used as input for the pattern matching start from the
-currently active recursion root. You usually give the recursion root(s)
-when invoking borg and these can be either relative or absolute paths.
+When specifying one or more file paths in a Borg command that supports
+patterns for the respective option or argument, you can apply the
+patterns described here to include only desired files and/or exclude
+unwanted ones. Patterns can be used
 
-So, when you give `relative/` as root, the paths going into the matcher
-will look like `relative/.../file.ext`. When you give `/absolute/` as
-root, they will look like `/absolute/.../file.ext`.
+- for ``--exclude`` option,
+- in the file given with ``--exclude-from`` option,
+- for ``--pattern`` option,
+- in the file given with ``--patterns-from`` option and
+- for ``PATH`` arguments that explicitly support them.
 
-File paths in Borg archives are always stored normalized and relative.
-This means that e.g. ``borg create /path/to/repo ../some/path`` will
-store all files as `some/path/.../file.ext` and ``borg create
-/path/to/repo /home/user`` will store all files as
-`home/user/.../file.ext`.
+Borg always stores all file paths normalized and relative to the
+current recursion root. The recursion root is also named ``PATH`` in
+Borg commands like `borg create` that do a file discovery, so do not
+confuse the root with the ``PATH`` argument of e.g. `borg extract`.
 
-A directory exclusion pattern can end either with or without a slash ('/').
-If it ends with a slash, such as `some/path/`, the directory will be
-included but not its content. If it does not end with a slash, such as
-`some/path`, both the directory and content will be excluded.
+Starting with Borg 1.2, paths that are matched against patterns always
+appear relative. If you give ``/absolute/`` as root, the paths going
+into the matcher will look relative like ``absolute/.../file.ext``.
+If you give ``../some/path`` as root, the paths will look like
+``some/path/.../file.ext``.
 
-File patterns support these styles: fnmatch, shell, regular expressions,
-path prefixes and path full-matches. By default, fnmatch is used for
-``--exclude`` patterns and shell-style is used for the ``--pattern``
-option. For commands that support patterns in their ``PATH`` argument
-like (``borg list``), the default pattern is path prefix.
+File patterns support five different styles. If followed by a colon ':',
+the first two characters of a pattern are used as a style selector.
+Explicit style selection is necessary if a non-default style is desired
+or when the desired pattern starts with two alphanumeric characters
+followed by a colon (i.e. ``aa:something/*``).
 
-Starting with Borg 1.2, for all but regular expression pattern matching
-styles, all paths are treated as relative, meaning that a leading path
-separator is removed after normalizing and before matching. This allows
-you to use absolute or relative patterns arbitrarily.
-
-If followed by a colon (':') the first two characters of a pattern are
-used as a style selector. Explicit style selection is necessary when a
-non-default style is desired or when the desired pattern starts with
-two alphanumeric characters followed by a colon (i.e. `aa:something/*`).
-
-`Fnmatch <https://docs.python.org/3/library/fnmatch.html>`_, selector `fm:`
+`Fnmatch <https://docs.python.org/3/library/fnmatch.html>`_, selector ``fm:``
     This is the default style for ``--exclude`` and ``--exclude-from``.
     These patterns use a variant of shell pattern syntax, with '\*' matching
     any number of characters, '?' matching any single character, '[...]'
@@ -49,7 +42,7 @@ two alphanumeric characters followed by a colon (i.e. `aa:something/*`).
     matching any character not specified. For the purpose of these patterns,
     the path separator (backslash for Windows and '/' on other systems) is not
     treated specially. Wrap meta-characters in brackets for a literal
-    match (i.e. `[?]` to match the literal character `?`). For a path
+    match (i.e. ``[?]`` to match the literal character '?'). For a path
     to match a pattern, the full path must match, or it must match
     from the start of the full path to just before a path separator. Except
     for the root path, paths will never end in the path separator when
@@ -57,33 +50,31 @@ two alphanumeric characters followed by a colon (i.e. `aa:something/*`).
     separator, a '\*' is appended before matching is attempted. A leading
     path separator is always removed.
 
-Shell-style patterns, selector `sh:`
+Shell-style patterns, selector ``sh:``
     This is the default style for ``--pattern`` and ``--patterns-from``.
     Like fnmatch patterns these are similar to shell patterns. The difference
-    is that the pattern may include `**/` for matching zero or more directory
-    levels, `*` for matching zero or more arbitrary characters with the
+    is that the pattern may include ``**/`` for matching zero or more directory
+    levels, ``*`` for matching zero or more arbitrary characters with the
     exception of any path separator. A leading path separator is always removed.
 
-Regular expressions, selector `re:`
-    Regular expressions similar to those found in Perl are supported. Unlike
-    shell patterns regular expressions are not required to match the full
+`Regular expressions <https://docs.python.org/3/library/re.html>`_, selector ``re:``
+    Unlike shell patterns, regular expressions are not required to match the full
     path and any substring match is sufficient. It is strongly recommended to
     anchor patterns to the start ('^'), to the end ('$') or both. Path
     separators (backslash for Windows and '/' on other systems) in paths are
-    always normalized to a forward slash ('/') before applying a pattern. The
-    regular expression syntax is described in the `Python documentation for
-    the re module <https://docs.python.org/3/library/re.html>`_.
+    always normalized to a forward slash '/' before applying a pattern.
 
-Path prefix, selector `pp:`
+Path prefix, selector ``pp:``
     This pattern style is useful to match whole sub-directories. The pattern
-    `pp:root/somedir` matches `root/somedir` and everything therein. A leading
-    path separator is always removed.
+    ``pp:root/somedir`` matches ``root/somedir`` and everything therein.
+    A leading path separator is always removed.
 
-Path full-match, selector `pf:`
+Path full-match, selector ``pf:``
     This pattern style is (only) useful to match full paths.
     This is kind of a pseudo pattern as it can not have any variable or
-    unspecified parts - the full path must be given. `pf:root/file.ext` matches
-    `root/file.ext` only. A leading path separator is always removed.
+    unspecified parts - the full path must be given. ``pf:root/file.ext``
+    matches ``root/file.ext`` only. A leading path separator is always
+    removed.
 
     Implementation note: this is implemented via very time-efficient O(1)
     hashtable lookups (this means you can have huge amounts of such patterns
@@ -96,20 +87,20 @@ Path full-match, selector `pf:`
 
 .. note::
 
-    `re:`, `sh:` and `fm:` patterns are all implemented on top of the Python SRE
-    engine. It is very easy to formulate patterns for each of these types which
-    requires an inordinate amount of time to match paths. If untrusted users
-    are able to supply patterns, ensure they cannot supply `re:` patterns.
-    Further, ensure that `sh:` and `fm:` patterns only contain a handful of
-    wildcards at most.
+    ``re:``, ``sh:`` and ``fm:`` patterns are all implemented on top of
+    the Python SRE engine. It is very easy to formulate patterns for each
+    of these types which requires an inordinate amount of time to match
+    paths. If untrusted users are able to supply patterns, ensure they
+    cannot supply ``re:`` patterns. Further, ensure that ``sh:`` and
+    ``fm:`` patterns only contain a handful of wildcards at most.
 
 Exclusions can be passed via the command line option ``--exclude``. When used
 from within a shell, the patterns should be quoted to protect them from
 expansion.
 
 The ``--exclude-from`` option permits loading exclusion patterns from a text
-file with one pattern per line. Lines empty or starting with the number sign
-('#') after removing whitespace on both ends are ignored. The optional style
+file with one pattern per line. Lines empty or starting with the hash sign
+'#' after removing whitespace on both ends are ignored. The optional style
 selector prefix is also supported for patterns loaded from a file. Due to
 whitespace removal, paths with whitespace at the beginning or end can only be
 excluded using regular expressions.
@@ -120,63 +111,83 @@ run ``borg create --list --dry-run ...``.
 Examples::
 
     # Exclude '/home/user/file.o' but not '/home/user/file.odt':
-    $ borg create -e '*.o' backup /
+    $ borg create -e '*.o' archive /
 
     # Exclude '/home/user/junk' and '/home/user/subdir/junk' but
     # not '/home/user/importantjunk' or '/etc/junk':
-    $ borg create -e '/home/*/junk' backup /
+    $ borg create -e 'home/*/junk' archive /
 
     # Exclude the contents of '/home/user/cache' but not the directory itself:
-    $ borg create -e home/user/cache/ backup /
+    $ borg create -e home/user/cache/ archive /
 
     # The file '/home/user/cache/important' is *not* backed up:
-    $ borg create -e /home/user/cache/ backup / /home/user/cache/important
+    $ borg create -e home/user/cache/ archive / /home/user/cache/important
 
     # The contents of directories in '/home' are not backed up when their name
     # ends in '.tmp'
-    $ borg create --exclude 're:^/home/[^/]+\.tmp/' backup /
+    $ borg create --exclude 're:^home/[^/]+\.tmp/' archive /
 
     # Load exclusions from file
     $ cat >exclude.txt <<EOF
     # Comment line
-    /home/*/junk
+    home/*/junk
     *.tmp
     fm:aa:something/*
-    re:^/home/[^/]+\.tmp/
-    sh:/home/*/.thumbnails
+    re:^home/[^/]+\.tmp/
+    sh:home/*/.thumbnails
     # Example with spaces, no need to escape as it is processed by borg
     some file with spaces.txt
     EOF
-    $ borg create --exclude-from exclude.txt backup /
+    $ borg create --exclude-from exclude.txt archive /
 
-A more general and easier to use way to define filename matching patterns exists
-with the ``--pattern`` and ``--patterns-from`` options. Using these, you may
-specify the backup roots (starting points) and patterns for inclusion/exclusion.
-A root path starts with the prefix `R`, followed by a path (a plain path, not a
-file pattern). An include rule starts with the prefix +, an exclude rule starts
-with the prefix -, an exclude-norecurse rule starts with !, all followed by a pattern.
+A more general and easier to use way to define filename matching patterns
+exists with the ``--pattern`` and ``--patterns-from`` options. Using
+these, you may specify the backup roots, default pattern styles and
+patterns for inclusion and exclusion.
+
+Root path prefix ``R``
+    A recursion root path starts with the prefix ``R``, followed by a path
+    (a plain path, not a file pattern). Use this prefix to have the root
+    paths in the patterns file rather than as command line arguments.
+
+Pattern style prefix ``P``
+    To change the default pattern style, use the ``P`` prefix, followed by
+    the pattern style abbreviation (``fm``, ``pf``, ``pp``, ``re``, ``sh``).
+    All patterns following this line will use this style until another style
+    is specified.
+
+Exclude pattern prefix ``-``
+    Use the prefix ``-``, followed by a pattern, to define an exclusion.
+    This has the same effect as the ``--exclude`` option.
+
+Exclude no-recurse pattern prefix ``!``
+    Use the prefix ``!``, followed by a pattern, to define an exclusion
+    that does not recurse into subdirectories. This saves time, but
+    prevents include patterns to match any files in subdirectories.
+
+Include pattern prefix ``+``
+    Use the prefix ``+``, followed by a pattern, to define inclusions.
+    This is useful to include paths that are covered in an exclude
+    pattern and would otherwise not be backed up.
+
+The first matching pattern is used, so if an include pattern matches
+before an exclude pattern, the file is backed up. Note that a no-recurse
+exclude stops examination of subdirectories so that potential includes
+will not match - use normal exludes for such use cases.
+
+**Tip: You can easily test your patterns with --dry-run and  --list**::
+
+    $ borg create --dry-run --list --patterns-from patterns.txt archive
+
+This will list the considered files one per line, prefixed with a
+character that indicates the action (e.g. 'x' for excluding, see
+**Item flags** in `borg create` usage docs).
 
 .. note::
 
-    Via ``--pattern`` or ``--patterns-from`` you can define BOTH inclusion and exclusion
-    of files using pattern prefixes ``+`` and ``-``. With ``--exclude`` and
-    ``--exclude-from`` ONLY excludes are defined.
-
-Inclusion patterns are useful to include paths that are contained in an excluded
-path. The first matching pattern is used so if an include pattern matches before
-an exclude pattern, the file is backed up. If an exclude-norecurse pattern matches
-a directory, it won't recurse into it and won't discover any potential matches for
-include rules below that directory.
-
-.. note::
-
-    It's possible that a sub-directory/file is matched while parent directories are not.
-    In that case, parent directories are not backed up thus their user, group, permission,
-    etc. can not be restored.
-
-Note that the default pattern style for ``--pattern`` and ``--patterns-from`` is
-shell style (`sh:`), so those patterns behave similar to rsync include/exclude
-patterns. The pattern style can be set via the `P` prefix.
+    It's possible that a sub-directory/file is matched while parent
+    directories are not. In that case, parent directories are not backed
+    up and thus their user, group, permission, etc. cannot be restored.
 
 Patterns (``--pattern``) and excludes (``--exclude``) from the command line are
 considered first (in the order of appearance). Then patterns from ``--patterns-from``
@@ -186,45 +197,45 @@ Examples::
 
     # backup pics, but not the ones from 2018, except the good ones:
     # note: using = is essential to avoid cmdline argument parsing issues.
-    borg create --pattern=+pics/2018/good --pattern=-pics/2018 repo::arch pics
+    borg create --pattern=+pics/2018/good --pattern=-pics/2018 archive pics
 
-    # use a file with patterns:
-    borg create --patterns-from patterns.lst repo::arch
+    # backup only JPG/JPEG files (case insensitive) in all home directories:
+    borg create --pattern '+ re:\.jpe?g(?i)$' archive /home
+
+    # backup homes, but exclude big downloads (like .ISO files) or hidden files:
+    borg create --exclude 're:\.iso(?i)$' --exclude 'sh:home/**/.*' archive /home
+
+    # use a file with patterns (recursion root '/' via command line):
+    borg create --patterns-from patterns.lst archive /
 
 The patterns.lst file could look like that::
 
-    # "sh:" pattern style is the default, so the following line is not needed:
-    P sh
-    R /
-    # can be rebuild
-    - /home/*/.cache
-    # they're downloads for a reason
-    - /home/*/Downloads
-    # susan is a nice person
+    # "sh:" pattern style is the default
+    # exclude caches
+    - home/*/.cache
     # include susans home
-    + /home/susan
+    + home/susan
     # also back up this exact file
-    + pf:/home/bobby/specialfile.txt
+    + pf:home/bobby/specialfile.txt
     # don't backup the other home directories
-    - /home/*
-    # don't even look in /proc
-    ! /proc
+    - home/*
+    # don't even look in /dev, /proc, /run, /sys, /tmp (note: would exclude files like /device, too)
+    ! re:^(dev|proc|run|sys|tmp)
 
 You can specify recursion roots either on the command line or in a patternfile::
 
     # these two commands do the same thing
-    borg create --exclude /home/bobby/junk repo::arch /home/bobby /home/susan
-    borg create --patterns-from patternfile.lst repo::arch
+    borg create --exclude home/bobby/junk archive /home/bobby /home/susan
+    borg create --patterns-from patternfile.lst archive
 
-The patternfile::
+patternfile.lst::
 
     # note that excludes use fm: by default and patternfiles use sh: by default.
     # therefore, we need to specify fm: to have the same exact behavior.
     P fm
     R /home/bobby
     R /home/susan
-
-    - /home/bobby/junk
+    - home/bobby/junk
 
 This allows you to share the same patterns between multiple repositories
 without needing to specify them on the command line.
@@ -235,7 +246,7 @@ borg help placeholders
 ~~~~~~~~~~~~~~~~~~~~~~
 
 
-Repository (or Archive) URLs, ``--prefix``, ``--glob-archives``, ``--comment``
+Repository URLs, ``--name``, ``--prefix``, ``--glob-archives``, ``--comment``
 and ``--remote-path`` values support these placeholders:
 
 {hostname}
diff --git a/docs/usage/import-tar.rst.inc b/docs/usage/import-tar.rst.inc
index c76bbfe20..94087ceec 100644
--- a/docs/usage/import-tar.rst.inc
+++ b/docs/usage/import-tar.rst.inc
@@ -6,7 +6,7 @@ borg import-tar
 ---------------
 .. code-block:: none
 
-    borg [common options] import-tar [options] ARCHIVE TARFILE
+    borg [common options] import-tar [options] NAME TARFILE
 
 .. only:: html
 
@@ -15,7 +15,7 @@ borg import-tar
     +-------------------------------------------------------+---------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------+
     | **positional arguments**                                                                                                                                                                                                                          |
     +-------------------------------------------------------+---------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------+
-    |                                                       | ``ARCHIVE``                                       | name of archive to create (must be also a valid directory name)                                                                       |
+    |                                                       | ``NAME``                                          | specify the archive name                                                                                                              |
     +-------------------------------------------------------+---------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------+
     |                                                       | ``TARFILE``                                       | input tar file. "-" to read from stdin instead.                                                                                       |
     +-------------------------------------------------------+---------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------+
@@ -58,8 +58,8 @@ borg import-tar
 
 .. only:: latex
 
-    ARCHIVE
-        name of archive to create (must be also a valid directory name)
+    NAME
+        specify the archive name
     TARFILE
         input tar file. "-" to read from stdin instead.
 
diff --git a/docs/usage/info.rst b/docs/usage/info.rst
index 542ff5efb..36aa623fa 100644
--- a/docs/usage/info.rst
+++ b/docs/usage/info.rst
@@ -4,55 +4,17 @@ Examples
 ~~~~~~~~
 ::
 
-    $ borg info /path/to/repo::2017-06-29T11:00-srv
-    Archive name: 2017-06-29T11:00-srv
-    Archive fingerprint: b2f1beac2bd553b34e06358afa45a3c1689320d39163890c5bbbd49125f00fe5
+    $ borg info Tuesday2022-06-25T20:51:39
+    Archive name: Tuesday2022-06-25T20:51:39
+    Archive fingerprint: f7dea0788dfc026cc2be1c0f5b94beb4e4084eb3402fc40c38d8719b1bf2d943
     Comment:
-    Hostname: myhostname
-    Username: root
-    Time (start): Thu, 2017-06-29 11:03:07
-    Time (end): Thu, 2017-06-29 11:03:13
-    Duration: 5.66 seconds
-    Number of files: 17037
-    Command line: /usr/sbin/borg create /path/to/repo::2017-06-29T11:00-srv /srv
-    Utilization of max. archive size: 0%
-    ------------------------------------------------------------------------------
-                           Original size      Compressed size    Deduplicated size
-    This archive:               12.53 GB             12.49 GB              1.62 kB
-    All archives:              121.82 TB            112.41 TB            215.42 GB
-
-                           Unique chunks         Total chunks
-    Chunk index:                 1015213            626934122
-
-    $ borg info /path/to/repo --last 1
-    Archive name: 2017-06-29T11:00-srv
-    Archive fingerprint: b2f1beac2bd553b34e06358afa45a3c1689320d39163890c5bbbd49125f00fe5
-    Comment:
-    Hostname: myhostname
-    Username: root
-    Time (start): Thu, 2017-06-29 11:03:07
-    Time (end): Thu, 2017-06-29 11:03:13
-    Duration: 5.66 seconds
-    Number of files: 17037
-    Command line: /usr/sbin/borg create /path/to/repo::2017-06-29T11:00-srv /srv
-    Utilization of max. archive size: 0%
-    ------------------------------------------------------------------------------
-                           Original size      Compressed size    Deduplicated size
-    This archive:               12.53 GB             12.49 GB              1.62 kB
-    All archives:              121.82 TB            112.41 TB            215.42 GB
-
-                           Unique chunks         Total chunks
-    Chunk index:                 1015213            626934122
-
-    $ borg info /path/to/repo
-    Repository ID: d857ce5788c51272c61535062e89eac4e8ef5a884ffbe976e0af9d8765dedfa5
-    Location: /path/to/repo
-    Encrypted: Yes (repokey)
-    Cache: /root/.cache/borg/d857ce5788c51272c61535062e89eac4e8ef5a884ffbe976e0af9d8765dedfa5
-    Security dir: /root/.config/borg/security/d857ce5788c51272c61535062e89eac4e8ef5a884ffbe976e0af9d8765dedfa5
-    ------------------------------------------------------------------------------
-                           Original size      Compressed size    Deduplicated size
-    All archives:              121.82 TB            112.41 TB            215.42 GB
-
-                           Unique chunks         Total chunks
-    Chunk index:                 1015213            626934122
+    Hostname: mba2020
+    Username: tw
+    Time (start): Sat, 2022-06-25 20:51:40
+    Time (end): Sat, 2022-06-25 20:51:40
+    Duration: 0.03 seconds
+    Command line: /Users/tw/w/borg-env/bin/borg -r path/to/repo create --stats 'Tuesday{now}' src --progress
+    Utilization of maximum supported archive size: 0%
+    Number of files: 244
+    Original size: 13.80 MB
+    Deduplicated size: 531 B
diff --git a/docs/usage/info.rst.inc b/docs/usage/info.rst.inc
index 0d6bfe915..915ffca6f 100644
--- a/docs/usage/info.rst.inc
+++ b/docs/usage/info.rst.inc
@@ -6,16 +6,12 @@ borg info
 ---------
 .. code-block:: none
 
-    borg [common options] info [options] [REPOSITORY_OR_ARCHIVE]
+    borg [common options] info [options]
 
 .. only:: html
 
     .. class:: borg-options-table
 
-    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------+
-    | **positional arguments**                                                                                                                                                                                                                                                     |
-    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------+
-    |                                                                             | ``REPOSITORY_OR_ARCHIVE``             | repository or archive to display information about                                                                                                     |
     +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------+
     | **optional arguments**                                                                                                                                                                                                                                                       |
     +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------+
@@ -48,8 +44,6 @@ borg info
 
 .. only:: latex
 
-    REPOSITORY_OR_ARCHIVE
-        repository or archive to display information about
 
 
     optional arguments
@@ -70,7 +64,7 @@ borg info
 Description
 ~~~~~~~~~~~
 
-This command displays detailed information about the specified archive or repository.
+This command displays detailed information about the specified archive.
 
 Please note that the deduplicated sizes of the individual archives do not add
 up to the deduplicated size of the repository ("all archives"), because the two
diff --git a/docs/usage/init.rst b/docs/usage/init.rst
deleted file mode 100644
index 73e62bb79..000000000
--- a/docs/usage/init.rst
+++ /dev/null
@@ -1,22 +0,0 @@
-.. include:: init.rst.inc
-
-Examples
-~~~~~~~~
-::
-
-    # Local repository, recommended repokey AEAD crypto modes
-    $ borg init --encryption=repokey-aes-ocb /path/to/repo
-    $ borg init --encryption=repokey-chacha20-poly1305 /path/to/repo
-    $ borg init --encryption=repokey-blake2-aes-ocb /path/to/repo
-    $ borg init --encryption=repokey-blake2-chacha20-poly1305 /path/to/repo
-
-    # Local repository (no encryption), not recommended
-    $ borg init --encryption=none /path/to/repo
-
-    # Remote repository (accesses a remote borg via ssh)
-    # repokey: stores the (encrypted) key into <REPO_DIR>/config
-    $ borg init --encryption=repokey-aes-ocb user@hostname:backup
-
-    # Remote repository (accesses a remote borg via ssh)
-    # keyfile: stores the (encrypted) key into ~/.config/borg/keys/
-    $ borg init --encryption=keyfile-aes-ocb user@hostname:backup
diff --git a/docs/usage/key.rst b/docs/usage/key.rst
index f175ac1d7..d1c08328c 100644
--- a/docs/usage/key.rst
+++ b/docs/usage/key.rst
@@ -11,7 +11,7 @@ Examples
 ::
 
     # Create a key file protected repository
-    $ borg init --encryption=keyfile -v /path/to/repo
+    $ borg rcreate --encryption=keyfile -v
     Initializing repository at "/path/to/repo"
     Enter new passphrase:
     Enter same passphrase again:
@@ -23,7 +23,7 @@ Examples
     Done.
 
     # Change key file passphrase
-    $ borg key change-passphrase -v /path/to/repo
+    $ borg key change-passphrase -v
     Enter passphrase for key /root/.config/borg/keys/mnt_backup:
     Enter new passphrase:
     Enter same passphrase again:
@@ -33,15 +33,15 @@ Examples
     # Import a previously-exported key into the specified
     # key file (creating or overwriting the output key)
     # (keyfile repositories only)
-    $ BORG_KEY_FILE=/path/to/output-key borg key import /path/to/repo /path/to/exported
+    $ BORG_KEY_FILE=/path/to/output-key borg key import /path/to/exported
 
 Fully automated using environment variables:
 
 ::
 
-    $ BORG_NEW_PASSPHRASE=old borg init -e=repokey repo
+    $ BORG_NEW_PASSPHRASE=old borg rcreate -e=repokey
     # now "old" is the current passphrase.
-    $ BORG_PASSPHRASE=old BORG_NEW_PASSPHRASE=new borg key change-passphrase repo
+    $ BORG_PASSPHRASE=old BORG_NEW_PASSPHRASE=new borg key change-passphrase
     # now "new" is the current passphrase.
 
 
diff --git a/docs/usage/key_change-algorithm.rst.inc b/docs/usage/key_change-algorithm.rst.inc
index 27b2e4e05..55e210ff5 100644
--- a/docs/usage/key_change-algorithm.rst.inc
+++ b/docs/usage/key_change-algorithm.rst.inc
@@ -6,23 +6,21 @@ borg key change-algorithm
 -------------------------
 .. code-block:: none
 
-    borg [common options] key change-algorithm [options] [REPOSITORY] ALGORITHM
+    borg [common options] key change-algorithm [options] ALGORITHM
 
 .. only:: html
 
     .. class:: borg-options-table
 
-    +-------------------------------------------------------+----------------+----------------------+
-    | **positional arguments**                                                                      |
-    +-------------------------------------------------------+----------------+----------------------+
-    |                                                       | ``REPOSITORY`` |                      |
-    +-------------------------------------------------------+----------------+----------------------+
-    |                                                       | ``ALGORITHM``  | select key algorithm |
-    +-------------------------------------------------------+----------------+----------------------+
-    | .. class:: borg-common-opt-ref                                                                |
-    |                                                                                               |
-    | :ref:`common_options`                                                                         |
-    +-------------------------------------------------------+----------------+----------------------+
+    +-------------------------------------------------------+---------------+----------------------+
+    | **positional arguments**                                                                     |
+    +-------------------------------------------------------+---------------+----------------------+
+    |                                                       | ``ALGORITHM`` | select key algorithm |
+    +-------------------------------------------------------+---------------+----------------------+
+    | .. class:: borg-common-opt-ref                                                               |
+    |                                                                                              |
+    | :ref:`common_options`                                                                        |
+    +-------------------------------------------------------+---------------+----------------------+
 
     .. raw:: html
 
@@ -34,8 +32,6 @@ borg key change-algorithm
 
 .. only:: latex
 
-    REPOSITORY
-
     ALGORITHM
         select key algorithm
 
diff --git a/docs/usage/key_change-location.rst.inc b/docs/usage/key_change-location.rst.inc
index 879eae995..4480e7d2c 100644
--- a/docs/usage/key_change-location.rst.inc
+++ b/docs/usage/key_change-location.rst.inc
@@ -6,7 +6,7 @@ borg key change-location
 ------------------------
 .. code-block:: none
 
-    borg [common options] key change-location [options] [REPOSITORY] KEY_LOCATION
+    borg [common options] key change-location [options] KEY_LOCATION
 
 .. only:: html
 
@@ -15,8 +15,6 @@ borg key change-location
     +-------------------------------------------------------+------------------+----------------------------------------------------------------+
     | **positional arguments**                                                                                                                  |
     +-------------------------------------------------------+------------------+----------------------------------------------------------------+
-    |                                                       | ``REPOSITORY``   |                                                                |
-    +-------------------------------------------------------+------------------+----------------------------------------------------------------+
     |                                                       | ``KEY_LOCATION`` | select key location                                            |
     +-------------------------------------------------------+------------------+----------------------------------------------------------------+
     | **optional arguments**                                                                                                                    |
@@ -38,8 +36,6 @@ borg key change-location
 
 .. only:: latex
 
-    REPOSITORY
-
     KEY_LOCATION
         select key location
 
@@ -56,8 +52,10 @@ Description
 
 Change the location of a borg key. The key can be stored at different locations:
 
-keyfile: locally, usually in the home directory
-repokey: inside the repo (in the repo config)
+- keyfile: locally, usually in the home directory
+- repokey: inside the repo (in the repo config)
 
-Note: this command does NOT change the crypto algorithms, just the key location,
-      thus you must ONLY give the key location (keyfile or repokey).
\ No newline at end of file
+Please note:
+
+This command does NOT change the crypto algorithms, just the key location,
+thus you must ONLY give the key location (keyfile or repokey).
\ No newline at end of file
diff --git a/docs/usage/key_change-passphrase.rst.inc b/docs/usage/key_change-passphrase.rst.inc
index ab31b9fde..880cf88d9 100644
--- a/docs/usage/key_change-passphrase.rst.inc
+++ b/docs/usage/key_change-passphrase.rst.inc
@@ -6,21 +6,17 @@ borg key change-passphrase
 --------------------------
 .. code-block:: none
 
-    borg [common options] key change-passphrase [options] [REPOSITORY]
+    borg [common options] key change-passphrase [options]
 
 .. only:: html
 
     .. class:: borg-options-table
 
-    +-------------------------------------------------------+----------------+--+
-    | **positional arguments**                                                  |
-    +-------------------------------------------------------+----------------+--+
-    |                                                       | ``REPOSITORY`` |  |
-    +-------------------------------------------------------+----------------+--+
-    | .. class:: borg-common-opt-ref                                            |
-    |                                                                           |
-    | :ref:`common_options`                                                     |
-    +-------------------------------------------------------+----------------+--+
+    +-------------------------------------------------------+
+    | .. class:: borg-common-opt-ref                        |
+    |                                                       |
+    | :ref:`common_options`                                 |
+    +-------------------------------------------------------+
 
     .. raw:: html
 
@@ -32,8 +28,6 @@ borg key change-passphrase
 
 .. only:: latex
 
-    REPOSITORY
-
 
 
     :ref:`common_options`
diff --git a/docs/usage/key_export.rst.inc b/docs/usage/key_export.rst.inc
index 0a57bf091..536c520ce 100644
--- a/docs/usage/key_export.rst.inc
+++ b/docs/usage/key_export.rst.inc
@@ -6,29 +6,27 @@ borg key export
 ---------------
 .. code-block:: none
 
-    borg [common options] key export [options] [REPOSITORY] [PATH]
+    borg [common options] key export [options] [PATH]
 
 .. only:: html
 
     .. class:: borg-options-table
 
-    +-------------------------------------------------------+----------------+------------------------------------------------------------------------+
-    | **positional arguments**                                                                                                                        |
-    +-------------------------------------------------------+----------------+------------------------------------------------------------------------+
-    |                                                       | ``REPOSITORY`` |                                                                        |
-    +-------------------------------------------------------+----------------+------------------------------------------------------------------------+
-    |                                                       | ``PATH``       | where to store the backup                                              |
-    +-------------------------------------------------------+----------------+------------------------------------------------------------------------+
-    | **optional arguments**                                                                                                                          |
-    +-------------------------------------------------------+----------------+------------------------------------------------------------------------+
-    |                                                       | ``--paper``    | Create an export suitable for printing and later type-in               |
-    +-------------------------------------------------------+----------------+------------------------------------------------------------------------+
-    |                                                       | ``--qr-html``  | Create an html file suitable for printing and later type-in or qr scan |
-    +-------------------------------------------------------+----------------+------------------------------------------------------------------------+
-    | .. class:: borg-common-opt-ref                                                                                                                  |
-    |                                                                                                                                                 |
-    | :ref:`common_options`                                                                                                                           |
-    +-------------------------------------------------------+----------------+------------------------------------------------------------------------+
+    +-------------------------------------------------------+---------------+------------------------------------------------------------------------+
+    | **positional arguments**                                                                                                                       |
+    +-------------------------------------------------------+---------------+------------------------------------------------------------------------+
+    |                                                       | ``PATH``      | where to store the backup                                              |
+    +-------------------------------------------------------+---------------+------------------------------------------------------------------------+
+    | **optional arguments**                                                                                                                         |
+    +-------------------------------------------------------+---------------+------------------------------------------------------------------------+
+    |                                                       | ``--paper``   | Create an export suitable for printing and later type-in               |
+    +-------------------------------------------------------+---------------+------------------------------------------------------------------------+
+    |                                                       | ``--qr-html`` | Create an html file suitable for printing and later type-in or qr scan |
+    +-------------------------------------------------------+---------------+------------------------------------------------------------------------+
+    | .. class:: borg-common-opt-ref                                                                                                                 |
+    |                                                                                                                                                |
+    | :ref:`common_options`                                                                                                                          |
+    +-------------------------------------------------------+---------------+------------------------------------------------------------------------+
 
     .. raw:: html
 
@@ -40,8 +38,6 @@ borg key export
 
 .. only:: latex
 
-    REPOSITORY
-
     PATH
         where to store the backup
 
diff --git a/docs/usage/key_import.rst.inc b/docs/usage/key_import.rst.inc
index a0890ff38..54492033e 100644
--- a/docs/usage/key_import.rst.inc
+++ b/docs/usage/key_import.rst.inc
@@ -6,27 +6,25 @@ borg key import
 ---------------
 .. code-block:: none
 
-    borg [common options] key import [options] [REPOSITORY] [PATH]
+    borg [common options] key import [options] [PATH]
 
 .. only:: html
 
     .. class:: borg-options-table
 
-    +-------------------------------------------------------+----------------+----------------------------------------------------------+
-    | **positional arguments**                                                                                                          |
-    +-------------------------------------------------------+----------------+----------------------------------------------------------+
-    |                                                       | ``REPOSITORY`` |                                                          |
-    +-------------------------------------------------------+----------------+----------------------------------------------------------+
-    |                                                       | ``PATH``       | path to the backup ('-' to read from stdin)              |
-    +-------------------------------------------------------+----------------+----------------------------------------------------------+
-    | **optional arguments**                                                                                                            |
-    +-------------------------------------------------------+----------------+----------------------------------------------------------+
-    |                                                       | ``--paper``    | interactively import from a backup done with ``--paper`` |
-    +-------------------------------------------------------+----------------+----------------------------------------------------------+
-    | .. class:: borg-common-opt-ref                                                                                                    |
-    |                                                                                                                                   |
-    | :ref:`common_options`                                                                                                             |
-    +-------------------------------------------------------+----------------+----------------------------------------------------------+
+    +-------------------------------------------------------+-------------+----------------------------------------------------------+
+    | **positional arguments**                                                                                                       |
+    +-------------------------------------------------------+-------------+----------------------------------------------------------+
+    |                                                       | ``PATH``    | path to the backup ('-' to read from stdin)              |
+    +-------------------------------------------------------+-------------+----------------------------------------------------------+
+    | **optional arguments**                                                                                                         |
+    +-------------------------------------------------------+-------------+----------------------------------------------------------+
+    |                                                       | ``--paper`` | interactively import from a backup done with ``--paper`` |
+    +-------------------------------------------------------+-------------+----------------------------------------------------------+
+    | .. class:: borg-common-opt-ref                                                                                                 |
+    |                                                                                                                                |
+    | :ref:`common_options`                                                                                                          |
+    +-------------------------------------------------------+-------------+----------------------------------------------------------+
 
     .. raw:: html
 
@@ -38,8 +36,6 @@ borg key import
 
 .. only:: latex
 
-    REPOSITORY
-
     PATH
         path to the backup ('-' to read from stdin)
 
diff --git a/docs/usage/list.rst b/docs/usage/list.rst
index 71dfe8eca..7fdc8d5d4 100644
--- a/docs/usage/list.rst
+++ b/docs/usage/list.rst
@@ -4,14 +4,7 @@ Examples
 ~~~~~~~~
 ::
 
-    $ borg list /path/to/repo
-    Monday                               Mon, 2016-02-15 19:15:11
-    repo                                 Mon, 2016-02-15 19:26:54
-    root-2016-02-15                      Mon, 2016-02-15 19:36:29
-    newname                              Mon, 2016-02-15 19:50:19
-    ...
-
-    $ borg list /path/to/repo::root-2016-02-15
+    $ borg list root-2016-02-15
     drwxr-xr-x root   root          0 Mon, 2016-02-15 17:44:27 .
     drwxrwxr-x root   root          0 Mon, 2016-02-15 19:04:49 bin
     -rwxr-xr-x root   root    1029624 Thu, 2014-11-13 00:08:51 bin/bash
@@ -19,14 +12,14 @@ Examples
     -rwxr-xr-x root   root       2140 Fri, 2015-03-27 20:24:22 bin/bzdiff
     ...
 
-    $ borg list /path/to/repo::root-2016-02-15 --pattern "- bin/ba*"
+    $ borg list root-2016-02-15 --pattern "- bin/ba*"
     drwxr-xr-x root   root          0 Mon, 2016-02-15 17:44:27 .
     drwxrwxr-x root   root          0 Mon, 2016-02-15 19:04:49 bin
     lrwxrwxrwx root   root          0 Fri, 2015-03-27 20:24:26 bin/bzcmp -> bzdiff
     -rwxr-xr-x root   root       2140 Fri, 2015-03-27 20:24:22 bin/bzdiff
     ...
 
-    $ borg list /path/to/repo::archiveA --format="{mode} {user:6} {group:6} {size:8d} {isomtime} {path}{extra}{NEWLINE}"
+    $ borg list archiveA --format="{mode} {user:6} {group:6} {size:8d} {isomtime} {path}{extra}{NEWLINE}"
     drwxrwxr-x user   user          0 Sun, 2015-02-01 11:00:00 .
     drwxrwxr-x user   user          0 Sun, 2015-02-01 11:00:00 code
     drwxrwxr-x user   user          0 Sun, 2015-02-01 11:00:00 code/myproject
@@ -34,11 +27,11 @@ Examples
     -rw-rw-r-- user   user    1416192 Sun, 2015-02-01 11:00:00 code/myproject/file.text
     ...
 
-    $ borg list /path/to/repo/::archiveA --pattern 're:\.ext$'
+    $ borg list archiveA --pattern 're:\.ext$'
     -rw-rw-r-- user   user    1416192 Sun, 2015-02-01 11:00:00 code/myproject/file.ext
     ...
 
-    $ borg list /path/to/repo/::archiveA --pattern 're:.ext$'
+    $ borg list archiveA --pattern 're:.ext$'
     -rw-rw-r-- user   user    1416192 Sun, 2015-02-01 11:00:00 code/myproject/file.ext
     -rw-rw-r-- user   user    1416192 Sun, 2015-02-01 11:00:00 code/myproject/file.text
     ...
diff --git a/docs/usage/list.rst.inc b/docs/usage/list.rst.inc
index 7b42cf812..4d17543ee 100644
--- a/docs/usage/list.rst.inc
+++ b/docs/usage/list.rst.inc
@@ -6,57 +6,41 @@ borg list
 ---------
 .. code-block:: none
 
-    borg [common options] list [options] [REPOSITORY_OR_ARCHIVE] [PATH...]
+    borg [common options] list [options] NAME [PATH...]
 
 .. only:: html
 
     .. class:: borg-options-table
 
-    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-    | **positional arguments**                                                                                                                                                                                                                                                                                                                                                                       |
-    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-    |                                                                             | ``REPOSITORY_OR_ARCHIVE``             | repository or archive to list contents of                                                                                                                                                                                                                                |
-    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-    |                                                                             | ``PATH``                              | paths to list; patterns are supported                                                                                                                                                                                                                                    |
-    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-    | **optional arguments**                                                                                                                                                                                                                                                                                                                                                                         |
-    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-    |                                                                             | ``--consider-checkpoints``            | Show checkpoint archives in the repository contents list (default: hidden).                                                                                                                                                                                              |
-    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-    |                                                                             | ``--short``                           | only print file/directory names, nothing else                                                                                                                                                                                                                            |
-    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-    |                                                                             | ``--format FORMAT``                   | specify format for file or archive listing (default for files: "{mode} {user:6} {group:6} {size:8} {mtime} {path}{extra}{NL}"; for archives: "{archive:<36} {time} [{id}]{NL}")                                                                                          |
-    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-    |                                                                             | ``--json``                            | Only valid for listing repository contents. Format output as JSON. The form of ``--format`` is ignored, but keys used in it are added to the JSON output. Some keys are always present. Note: JSON can only represent text. A "barchive" key is therefore not available. |
-    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-    |                                                                             | ``--json-lines``                      | Only valid for listing archive contents. Format output as JSON Lines. The form of ``--format`` is ignored, but keys used in it are added to the JSON output. Some keys are always present. Note: JSON can only represent text. A "bpath" key is therefore not available. |
-    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-    | .. class:: borg-common-opt-ref                                                                                                                                                                                                                                                                                                                                                                 |
-    |                                                                                                                                                                                                                                                                                                                                                                                                |
-    | :ref:`common_options`                                                                                                                                                                                                                                                                                                                                                                          |
-    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-    | **Archive filters** — Archive filters can be applied to repository targets.                                                                                                                                                                                                                                                                                                                    |
-    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-    |                                                                             | ``-P PREFIX``, ``--prefix PREFIX``    | only consider archive names starting with this prefix.                                                                                                                                                                                                                   |
-    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-    |                                                                             | ``-a GLOB``, ``--glob-archives GLOB`` | only consider archive names matching the glob. sh: rules apply, see "borg help patterns". ``--prefix`` and ``--glob-archives`` are mutually exclusive.                                                                                                                   |
-    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-    |                                                                             | ``--sort-by KEYS``                    | Comma-separated list of sorting keys; valid keys are: timestamp, name, id; default is: timestamp                                                                                                                                                                         |
-    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-    |                                                                             | ``--first N``                         | consider first N archives after other filters were applied                                                                                                                                                                                                               |
-    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-    |                                                                             | ``--last N``                          | consider last N archives after other filters were applied                                                                                                                                                                                                                |
-    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-    | **Exclusion options**                                                                                                                                                                                                                                                                                                                                                                          |
-    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-    |                                                                             | ``-e PATTERN``, ``--exclude PATTERN`` | exclude paths matching PATTERN                                                                                                                                                                                                                                           |
-    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-    |                                                                             | ``--exclude-from EXCLUDEFILE``        | read exclude patterns from EXCLUDEFILE, one per line                                                                                                                                                                                                                     |
-    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-    |                                                                             | ``--pattern PATTERN``                 | include/exclude paths matching PATTERN                                                                                                                                                                                                                                   |
-    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-    |                                                                             | ``--patterns-from PATTERNFILE``       | read include/exclude patterns from PATTERNFILE, one per line                                                                                                                                                                                                             |
-    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+    +-------------------------------------------------------+---------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+    | **positional arguments**                                                                                                                                                                                                                                                                                                        |
+    +-------------------------------------------------------+---------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+    |                                                       | ``NAME``                              | specify the archive name                                                                                                                                                                                                        |
+    +-------------------------------------------------------+---------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+    |                                                       | ``PATH``                              | paths to list; patterns are supported                                                                                                                                                                                           |
+    +-------------------------------------------------------+---------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+    | **optional arguments**                                                                                                                                                                                                                                                                                                          |
+    +-------------------------------------------------------+---------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+    |                                                       | ``--short``                           | only print file/directory names, nothing else                                                                                                                                                                                   |
+    +-------------------------------------------------------+---------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+    |                                                       | ``--format FORMAT``                   | specify format for file listing (default: "{mode} {user:6} {group:6} {size:8} {mtime} {path}{extra}{NL}")                                                                                                                       |
+    +-------------------------------------------------------+---------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+    |                                                       | ``--json-lines``                      | Format output as JSON Lines. The form of ``--format`` is ignored, but keys used in it are added to the JSON output. Some keys are always present. Note: JSON can only represent text. A "bpath" key is therefore not available. |
+    +-------------------------------------------------------+---------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+    | .. class:: borg-common-opt-ref                                                                                                                                                                                                                                                                                                  |
+    |                                                                                                                                                                                                                                                                                                                                 |
+    | :ref:`common_options`                                                                                                                                                                                                                                                                                                           |
+    +-------------------------------------------------------+---------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+    | **Exclusion options**                                                                                                                                                                                                                                                                                                           |
+    +-------------------------------------------------------+---------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+    |                                                       | ``-e PATTERN``, ``--exclude PATTERN`` | exclude paths matching PATTERN                                                                                                                                                                                                  |
+    +-------------------------------------------------------+---------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+    |                                                       | ``--exclude-from EXCLUDEFILE``        | read exclude patterns from EXCLUDEFILE, one per line                                                                                                                                                                            |
+    +-------------------------------------------------------+---------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+    |                                                       | ``--pattern PATTERN``                 | include/exclude paths matching PATTERN                                                                                                                                                                                          |
+    +-------------------------------------------------------+---------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+    |                                                       | ``--patterns-from PATTERNFILE``       | read include/exclude patterns from PATTERNFILE, one per line                                                                                                                                                                    |
+    +-------------------------------------------------------+---------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
 
     .. raw:: html
 
@@ -68,31 +52,21 @@ borg list
 
 .. only:: latex
 
-    REPOSITORY_OR_ARCHIVE
-        repository or archive to list contents of
+    NAME
+        specify the archive name
     PATH
         paths to list; patterns are supported
 
 
     optional arguments
-        --consider-checkpoints    Show checkpoint archives in the repository contents list (default: hidden).
         --short     only print file/directory names, nothing else
-        --format FORMAT    specify format for file or archive listing (default for files: "{mode} {user:6} {group:6} {size:8} {mtime} {path}{extra}{NL}"; for archives: "{archive:<36} {time} [{id}]{NL}")
-        --json      Only valid for listing repository contents. Format output as JSON. The form of ``--format`` is ignored, but keys used in it are added to the JSON output. Some keys are always present. Note: JSON can only represent text. A "barchive" key is therefore not available.
-        --json-lines    Only valid for listing archive contents. Format output as JSON Lines. The form of ``--format`` is ignored, but keys used in it are added to the JSON output. Some keys are always present. Note: JSON can only represent text. A "bpath" key is therefore not available.
+        --format FORMAT    specify format for file listing (default: "{mode} {user:6} {group:6} {size:8} {mtime} {path}{extra}{NL}")
+        --json-lines    Format output as JSON Lines. The form of ``--format`` is ignored, but keys used in it are added to the JSON output. Some keys are always present. Note: JSON can only represent text. A "bpath" key is therefore not available.
 
 
     :ref:`common_options`
         |
 
-    Archive filters
-        -P PREFIX, --prefix PREFIX        only consider archive names starting with this prefix.
-        -a GLOB, --glob-archives GLOB     only consider archive names matching the glob. sh: rules apply, see "borg help patterns". ``--prefix`` and ``--glob-archives`` are mutually exclusive.
-        --sort-by KEYS                    Comma-separated list of sorting keys; valid keys are: timestamp, name, id; default is: timestamp
-        --first N                         consider first N archives after other filters were applied
-        --last N                          consider last N archives after other filters were applied
-
-
     Exclusion options
         -e PATTERN, --exclude PATTERN     exclude paths matching PATTERN
         --exclude-from EXCLUDEFILE        read exclude patterns from EXCLUDEFILE, one per line
@@ -103,7 +77,7 @@ borg list
 Description
 ~~~~~~~~~~~
 
-This command lists the contents of a repository or an archive.
+This command lists the contents of an archive.
 
 For more help on include/exclude patterns, see the :ref:`borg_patterns` command output.
 
@@ -118,28 +92,17 @@ The ``--format`` option uses python's `format string syntax
 Examples:
 ::
 
-    $ borg list --format '{archive}{NL}' /path/to/repo
-    ArchiveFoo
-    ArchiveBar
-    ...
-
-    # {VAR:NUMBER} - pad to NUMBER columns.
-    # Strings are left-aligned, numbers are right-aligned.
-    # Note: time columns except ``isomtime``, ``isoctime`` and ``isoatime`` cannot be padded.
-    $ borg list --format '{archive:36} {time} [{id}]{NL}' /path/to/repo
-    ArchiveFoo                           Thu, 2021-12-09 10:22:28 [0b8e9a312bef3f2f6e2d0fc110c196827786c15eba0188738e81697a7fa3b274]
-    $ borg list --format '{mode} {user:6} {group:6} {size:8} {mtime} {path}{extra}{NL}' /path/to/repo::ArchiveFoo
+    $ borg list --format '{mode} {user:6} {group:6} {size:8} {mtime} {path}{extra}{NL}' ArchiveFoo
     -rw-rw-r-- user   user       1024 Thu, 2021-12-09 10:22:17 file-foo
     ...
 
     # {VAR:<NUMBER} - pad to NUMBER columns left-aligned.
     # {VAR:>NUMBER} - pad to NUMBER columns right-aligned.
-    $ borg list --format '{mode} {user:>6} {group:>6} {size:<8} {mtime} {path}{extra}{NL}' /path/to/repo::ArchiveFoo
+    $ borg list --format '{mode} {user:>6} {group:>6} {size:<8} {mtime} {path}{extra}{NL}' ArchiveFoo
     -rw-rw-r--   user   user 1024     Thu, 2021-12-09 10:22:17 file-foo
     ...
 
 The following keys are always available:
-
 - NEWLINE: OS dependent line separator
 - NL: alias of NEWLINE
 - NUL: NUL character for creating print0 / xargs -0 like output, see barchive and bpath keys below
@@ -148,24 +111,6 @@ The following keys are always available:
 - CR
 - LF
 
-Keys available only when listing archives in a repository:
-
-- archive: archive name interpreted as text (might be missing non-text characters, see barchive)
-- name: alias of "archive"
-- barchive: verbatim archive name, can contain any character except NUL
-- comment: archive comment interpreted as text (might be missing non-text characters, see bcomment)
-- bcomment: verbatim archive comment, can contain any character except NUL
-- id: internal ID of the archive
-
-- start: time (start) of creation of the archive
-- time: alias of "start"
-- end: time (end) of creation of the archive
-- command_line: command line which was used to create the archive
-
-- hostname: hostname of host on which this archive was created
-- username: username of user who created this archive
-
-
 Keys available only when listing files in an archive:
 
 - type
@@ -176,14 +121,13 @@ Keys available only when listing files in an archive:
 - group
 - path: path interpreted as text (might be missing non-text characters, see bpath)
 - bpath: verbatim POSIX path, can contain any character except NUL
-- source: link target for links (identical to linktarget)
+- source: link target for symlinks (identical to linktarget)
 - linktarget
+- hlid: hard link identity (same if hardlinking same fs object)
 - flags
 
 - size
-- csize: compressed size
 - dsize: deduplicated size
-- dcsize: deduplicated compressed size
 - num_chunks: number of chunks in this file
 - unique_chunks: number of unique chunks in this file
 
diff --git a/docs/usage/mount.rst b/docs/usage/mount.rst
index dcc57f494..a7075efaa 100644
--- a/docs/usage/mount.rst
+++ b/docs/usage/mount.rst
@@ -10,21 +10,14 @@ Examples
     # Mounting the repository shows all archives.
     # Archives are loaded lazily, expect some delay when navigating to an archive
     # for the first time.
-    $ borg mount /path/to/repo /tmp/mymountpoint
+    $ borg mount /tmp/mymountpoint
     $ ls /tmp/mymountpoint
     root-2016-02-14 root-2016-02-15
     $ borg umount /tmp/mymountpoint
 
-    # Mounting a specific archive is possible as well.
-    $ borg mount /path/to/repo::root-2016-02-15 /tmp/mymountpoint
-    $ ls /tmp/mymountpoint
-    bin  boot  etc	home  lib  lib64  lost+found  media  mnt  opt
-    root  sbin  srv  tmp  usr  var
-    $ borg umount /tmp/mymountpoint
-
     # The "versions view" merges all archives in the repository
     # and provides a versioned view on files.
-    $ borg mount -o versions /path/to/repo /tmp/mymountpoint
+    $ borg mount -o versions /tmp/mymountpoint
     $ ls -l /tmp/mymountpoint/home/user/doc.txt/
     total 24
     -rw-rw-r-- 1 user group 12357 Aug 26 21:19 doc.cda00bc9.txt
@@ -34,12 +27,12 @@ Examples
     # Archive filters are supported.
     # These are especially handy for the "versions view",
     # which does not support lazy processing of archives.
-    $ borg mount -o versions --glob-archives '*-my-home' --last 10 /path/to/repo /tmp/mymountpoint
+    $ borg mount -o versions --glob-archives '*-my-home' --last 10 /tmp/mymountpoint
 
     # Exclusion options are supported.
     # These can speed up mounting and lower memory needs significantly.
     $ borg mount /path/to/repo /tmp/mymountpoint only/that/path
-    $ borg mount --exclude '...' /path/to/repo /tmp/mymountpoint
+    $ borg mount --exclude '...' /tmp/mymountpoint
 
 
 borgfs
@@ -48,13 +41,9 @@ borgfs
 ::
 
     $ echo '/mnt/backup /tmp/myrepo fuse.borgfs defaults,noauto 0 0' >> /etc/fstab
-    $ echo '/mnt/backup::root-2016-02-15 /tmp/myarchive fuse.borgfs defaults,noauto 0 0' >> /etc/fstab
     $ mount /tmp/myrepo
-    $ mount /tmp/myarchive
     $ ls /tmp/myrepo
     root-2016-02-01 root-2016-02-2015
-    $ ls /tmp/myarchive
-    bin  boot  etc	home  lib  lib64  lost+found  media  mnt  opt  root  sbin  srv  tmp  usr  var
 
 .. Note::
 
diff --git a/docs/usage/mount.rst.inc b/docs/usage/mount.rst.inc
index a720f88a1..0e3103819 100644
--- a/docs/usage/mount.rst.inc
+++ b/docs/usage/mount.rst.inc
@@ -6,7 +6,7 @@ borg mount
 ----------
 .. code-block:: none
 
-    borg [common options] mount [options] REPOSITORY_OR_ARCHIVE MOUNTPOINT [PATH...]
+    borg [common options] mount [options] MOUNTPOINT [PATH...]
 
 .. only:: html
 
@@ -15,8 +15,6 @@ borg mount
     +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------+
     | **positional arguments**                                                                                                                                                                                                                                                     |
     +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------+
-    |                                                                             | ``REPOSITORY_OR_ARCHIVE``             | repository or archive to mount                                                                                                                         |
-    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------+
     |                                                                             | ``MOUNTPOINT``                        | where to mount filesystem                                                                                                                              |
     +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------+
     |                                                                             | ``PATH``                              | paths to extract; patterns are supported                                                                                                               |
@@ -72,8 +70,6 @@ borg mount
 
 .. only:: latex
 
-    REPOSITORY_OR_ARCHIVE
-        repository or archive to mount
     MOUNTPOINT
         where to mount filesystem
     PATH
diff --git a/docs/usage/notes.rst b/docs/usage/notes.rst
index 546b6bf9c..7ecdcdca4 100644
--- a/docs/usage/notes.rst
+++ b/docs/usage/notes.rst
@@ -155,18 +155,18 @@ After the backup has completed, you remove the snapshots again.
 
     $ # create snapshots here
     $ lvdisplay > lvdisplay.txt
-    $ borg create --read-special /path/to/repo::arch lvdisplay.txt /dev/vg0/*-snapshot
+    $ borg create --read-special arch lvdisplay.txt /dev/vg0/*-snapshot
     $ # remove snapshots here
 
 Now, let's see how to restore some LVs from such a backup.
 
 ::
 
-    $ borg extract /path/to/repo::arch lvdisplay.txt
+    $ borg extract arch lvdisplay.txt
     $ # create empty LVs with correct sizes here (look into lvdisplay.txt).
     $ # we assume that you created an empty root and home LV and overwrite it now:
-    $ borg extract --stdout /path/to/repo::arch dev/vg0/root-snapshot > /dev/vg0/root
-    $ borg extract --stdout /path/to/repo::arch dev/vg0/home-snapshot > /dev/vg0/home
+    $ borg extract --stdout arch dev/vg0/root-snapshot > /dev/vg0/root
+    $ borg extract --stdout arch dev/vg0/home-snapshot > /dev/vg0/home
 
 
 .. _separate_compaction:
@@ -219,7 +219,7 @@ To activate append-only mode, set ``append_only`` to 1 in the repository config:
 
 ::
 
-    borg config /path/to/repo append_only 1
+    borg config append_only 1
 
 Note that you can go back-and-forth between normal and append-only operation with
 ``borg config``; it's not a "one way trip."
@@ -237,7 +237,7 @@ in ``.ssh/authorized_keys``:
     command="borg serve ..." ssh-rsa <key used for backup management>
 
 Running ``borg init`` via a ``borg serve --append-only`` server will *not* create
-an append-only repository. Running ``borg init --append-only`` creates an append-only
+an append-only repository. Running ``borg rcreate --append-only`` creates an append-only
 repository regardless of server settings.
 
 Example
@@ -282,7 +282,7 @@ than what you actually have in the repository now, after the rollback.
 
 Thus, you need to clear the cache::
 
-    borg delete --cache-only repo
+    borg rdelete --cache-only
 
 The cache will get rebuilt automatically. Depending on repo size and archive
 count, it may take a while.
@@ -307,7 +307,7 @@ mode, this is reversible, but ``borg check`` should be run before a writing/prun
 operation on an append-only repository to catch accidental or malicious corruption::
 
     # run without append-only mode
-    borg check --verify-data repo && borg compact repo
+    borg check --verify-data && borg compact
 
 Aside from checking repository & archive integrity you may want to also manually check
 backups to ensure their content seems correct.
diff --git a/docs/usage/prune.rst b/docs/usage/prune.rst
index 6b0ac84b1..44880adb8 100644
--- a/docs/usage/prune.rst
+++ b/docs/usage/prune.rst
@@ -18,21 +18,21 @@ first so you will see what it would do without it actually doing anything.
 
     # Keep 7 end of day and 4 additional end of week archives.
     # Do a dry-run without actually deleting anything.
-    $ borg prune -v --list --dry-run --keep-daily=7 --keep-weekly=4 /path/to/repo
+    $ borg prune -v --list --dry-run --keep-daily=7 --keep-weekly=4
 
     # Same as above but only apply to archive names starting with the hostname
     # of the machine followed by a "-" character:
-    $ borg prune -v --list --keep-daily=7 --keep-weekly=4 --prefix='{hostname}-' /path/to/repo
+    $ borg prune -v --list --keep-daily=7 --keep-weekly=4 --prefix='{hostname}-'
     # actually free disk space:
-    $ borg compact /path/to/repo
+    $ borg compact
 
     # Keep 7 end of day, 4 additional end of week archives,
     # and an end of month archive for every month:
-    $ borg prune -v --list --keep-daily=7 --keep-weekly=4 --keep-monthly=-1 /path/to/repo
+    $ borg prune -v --list --keep-daily=7 --keep-weekly=4 --keep-monthly=-1
 
     # Keep all backups in the last 10 days, 4 additional end of week archives,
     # and an end of month archive for every month:
-    $ borg prune -v --list --keep-within=10d --keep-weekly=4 --keep-monthly=-1 /path/to/repo
+    $ borg prune -v --list --keep-within=10d --keep-weekly=4 --keep-monthly=-1
 
 There is also a visualized prune example in ``docs/misc/prune-example.txt``:
 
diff --git a/docs/usage/prune.rst.inc b/docs/usage/prune.rst.inc
index b5bd5b421..1189b68b5 100644
--- a/docs/usage/prune.rst.inc
+++ b/docs/usage/prune.rst.inc
@@ -6,16 +6,12 @@ borg prune
 ----------
 .. code-block:: none
 
-    borg [common options] prune [options] [REPOSITORY]
+    borg [common options] prune [options]
 
 .. only:: html
 
     .. class:: borg-options-table
 
-    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------+
-    | **positional arguments**                                                                                                                                                                                                                                                     |
-    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------+
-    |                                                                             | ``REPOSITORY``                        | repository to prune                                                                                                                                    |
     +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------+
     | **optional arguments**                                                                                                                                                                                                                                                       |
     +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------+
@@ -66,8 +62,6 @@ borg prune
 
 .. only:: latex
 
-    REPOSITORY
-        repository to prune
 
 
     optional arguments
diff --git a/docs/usage/rcreate.rst b/docs/usage/rcreate.rst
new file mode 100644
index 000000000..967387b01
--- /dev/null
+++ b/docs/usage/rcreate.rst
@@ -0,0 +1,25 @@
+.. _borg-rcreate:
+
+.. include:: rcreate.rst.inc
+
+Examples
+~~~~~~~~
+::
+
+    # Local repository
+    $ export BORG_REPO=/path/to/repo
+    # recommended repokey AEAD crypto modes
+    $ borg rcreate --encryption=repokey-aes-ocb
+    $ borg rcreate --encryption=repokey-chacha20-poly1305
+    $ borg rcreate --encryption=repokey-blake2-aes-ocb
+    $ borg rcreate --encryption=repokey-blake2-chacha20-poly1305
+    # no encryption, not recommended
+    $ borg rcreate --encryption=authenticated
+    $ borg rcreate --encryption=none
+
+    # Remote repository (accesses a remote borg via ssh)
+    $ export BORG_REPO=ssh://user@hostname/~/backup
+    # repokey: stores the (encrypted) key into <REPO_DIR>/config
+    $ borg rcreate --encryption=repokey-aes-ocb
+    # keyfile: stores the (encrypted) key into ~/.config/borg/keys/
+    $ borg rcreate --encryption=keyfile-aes-ocb
diff --git a/docs/usage/init.rst.inc b/docs/usage/rcreate.rst.inc
similarity index 91%
rename from docs/usage/init.rst.inc
rename to docs/usage/rcreate.rst.inc
index bfcfc40e0..3a4c99b2b 100644
--- a/docs/usage/init.rst.inc
+++ b/docs/usage/rcreate.rst.inc
@@ -1,24 +1,22 @@
 .. IMPORTANT: this file is auto-generated from borg's built-in help, do not edit!
 
-.. _borg_init:
+.. _borg_rcreate:
 
-borg init
----------
+borg rcreate
+------------
 .. code-block:: none
 
-    borg [common options] init [options] [REPOSITORY]
+    borg [common options] rcreate [options]
 
 .. only:: html
 
     .. class:: borg-options-table
 
-    +-------------------------------------------------------+------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-    | **positional arguments**                                                                                                                                                                                                                                                                                                            |
-    +-------------------------------------------------------+------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-    |                                                       | ``REPOSITORY``                     | repository to create                                                                                                                                                                                                                   |
     +-------------------------------------------------------+------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
     | **optional arguments**                                                                                                                                                                                                                                                                                                              |
     +-------------------------------------------------------+------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+    |                                                       | ``--other-repo SRC_REPOSITORY``    | reuse the key material from the other repository                                                                                                                                                                                       |
+    +-------------------------------------------------------+------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
     |                                                       | ``-e MODE``, ``--encryption MODE`` | select encryption key mode **(required)**                                                                                                                                                                                              |
     +-------------------------------------------------------+------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
     |                                                       | ``--append-only``                  | create an append-only mode repository. Note that this only affects the low level structure of the repository, and running `delete` or `prune` will still be allowed. See :ref:`append_only_mode` in Additional Notes for more details. |
@@ -44,11 +42,10 @@ borg init
 
 .. only:: latex
 
-    REPOSITORY
-        repository to create
 
 
     optional arguments
+        --other-repo SRC_REPOSITORY    reuse the key material from the other repository
         -e MODE, --encryption MODE     select encryption key mode **(required)**
         --append-only                  create an append-only mode repository. Note that this only affects the low level structure of the repository, and running `delete` or `prune` will still be allowed. See :ref:`append_only_mode` in Additional Notes for more details.
         --storage-quota QUOTA          Set storage quota of the new repository (e.g. 5G, 1.5T). Default: no quota.
@@ -62,7 +59,7 @@ borg init
 Description
 ~~~~~~~~~~~
 
-This command initializes an empty repository. A repository is a filesystem
+This command creates a new, empty repository. A repository is a filesystem
 directory containing the deduplicated data from zero or more archives.
 
 Encryption mode TLDR
@@ -75,7 +72,7 @@ tips will come below):
 
 ::
 
-    borg init --encryption repokey /path/to/repo
+    borg rcreate --encryption repokey-aes-ocb
 
 Borg will:
 
@@ -137,13 +134,13 @@ in the upper part of the table, in the lower part is the old and/or unsafe(r) st
 +-----------------------------------+--------------+----------------+--------------------+---------+
 | Mode (K = keyfile or repokey)     | ID-Hash      | Encryption     | Authentication     | V >=    |
 +-----------------------------------+--------------+----------------+--------------------+---------+
-| K-blake2-chacha20-poly1305        | BLAKE2b      | CHACHA20       | POLY1305           | 1.3     |
+| K-blake2-chacha20-poly1305        | BLAKE2b      | CHACHA20       | POLY1305           | 2.0     |
 +-----------------------------------+--------------+----------------+--------------------+---------+
-| K-chacha20-poly1305               | HMAC-SHA-256 | CHACHA20       | POLY1305           | 1.3     |
+| K-chacha20-poly1305               | HMAC-SHA-256 | CHACHA20       | POLY1305           | 2.0     |
 +-----------------------------------+--------------+----------------+--------------------+---------+
-| K-blake2-aes-ocb                  | BLAKE2b      | AES256-OCB     | AES256-OCB         | 1.3     |
+| K-blake2-aes-ocb                  | BLAKE2b      | AES256-OCB     | AES256-OCB         | 2.0     |
 +-----------------------------------+--------------+----------------+--------------------+---------+
-| K-aes-ocb                         | HMAC-SHA-256 | AES256-OCB     | AES256-OCB         | 1.3     |
+| K-aes-ocb                         | HMAC-SHA-256 | AES256-OCB     | AES256-OCB         | 2.0     |
 +-----------------------------------+--------------+----------------+--------------------+---------+
 | K-blake2                          | BLAKE2b      | AES256-CTR     | BLAKE2b            | 1.1     |
 +-----------------------------------+--------------+----------------+--------------------+---------+
@@ -172,8 +169,6 @@ Key derivation functions
   The key encryption key is derived from your passphrase via argon2-id.
   Argon2 is considered more modern and secure than pbkdf2.
 
-- You can use ``--key-algorithm pbkdf2`` if you want to access your repo via old versions of borg.
-
 Our implementation of argon2-based key algorithm follows the cryptographic best practices:
 
 - It derives two separate keys from your passphrase: one to encrypt your key and another one
diff --git a/docs/usage/rdelete.rst b/docs/usage/rdelete.rst
new file mode 100644
index 000000000..ee189f2cc
--- /dev/null
+++ b/docs/usage/rdelete.rst
@@ -0,0 +1,13 @@
+.. include:: rdelete.rst.inc
+
+Examples
+~~~~~~~~
+::
+
+    # delete the whole repository and the related local cache:
+    $ borg rdelete
+    You requested to completely DELETE the repository *including* all archives it contains:
+    repo                                 Mon, 2016-02-15 19:26:54
+    root-2016-02-15                      Mon, 2016-02-15 19:36:29
+    newname                              Mon, 2016-02-15 19:50:19
+    Type 'YES' if you understand this and want to continue: YES
diff --git a/docs/usage/rdelete.rst.inc b/docs/usage/rdelete.rst.inc
new file mode 100644
index 000000000..18d9bbc01
--- /dev/null
+++ b/docs/usage/rdelete.rst.inc
@@ -0,0 +1,66 @@
+.. IMPORTANT: this file is auto-generated from borg's built-in help, do not edit!
+
+.. _borg_rdelete:
+
+borg rdelete
+------------
+.. code-block:: none
+
+    borg [common options] rdelete [options]
+
+.. only:: html
+
+    .. class:: borg-options-table
+
+    +-------------------------------------------------------+--------------------------+--------------------------------------------------------------------------------------------------+
+    | **optional arguments**                                                                                                                                                              |
+    +-------------------------------------------------------+--------------------------+--------------------------------------------------------------------------------------------------+
+    |                                                       | ``-n``, ``--dry-run``    | do not change repository                                                                         |
+    +-------------------------------------------------------+--------------------------+--------------------------------------------------------------------------------------------------+
+    |                                                       | ``--list``               | output verbose list of archives                                                                  |
+    +-------------------------------------------------------+--------------------------+--------------------------------------------------------------------------------------------------+
+    |                                                       | ``--force``              | force deletion of corrupted archives, use ``--force --force`` in case ``--force`` does not work. |
+    +-------------------------------------------------------+--------------------------+--------------------------------------------------------------------------------------------------+
+    |                                                       | ``--cache-only``         | delete only the local cache for the given repository                                             |
+    +-------------------------------------------------------+--------------------------+--------------------------------------------------------------------------------------------------+
+    |                                                       | ``--keep-security-info`` | keep the local security info when deleting a repository                                          |
+    +-------------------------------------------------------+--------------------------+--------------------------------------------------------------------------------------------------+
+    | .. class:: borg-common-opt-ref                                                                                                                                                      |
+    |                                                                                                                                                                                     |
+    | :ref:`common_options`                                                                                                                                                               |
+    +-------------------------------------------------------+--------------------------+--------------------------------------------------------------------------------------------------+
+
+    .. raw:: html
+
+        <script type='text/javascript'>
+        $(document).ready(function () {
+            $('.borg-options-table colgroup').remove();
+        })
+        </script>
+
+.. only:: latex
+
+
+
+    optional arguments
+        -n, --dry-run     do not change repository
+        --list            output verbose list of archives
+        --force           force deletion of corrupted archives, use ``--force --force`` in case ``--force`` does not work.
+        --cache-only      delete only the local cache for the given repository
+        --keep-security-info    keep the local security info when deleting a repository
+
+
+    :ref:`common_options`
+        |
+
+Description
+~~~~~~~~~~~
+
+This command deletes the complete repository.
+
+When you delete a complete repository, the security info and local cache for it
+(if any) are also deleted. Alternatively, you can delete just the local cache
+with the ``--cache-only`` option, or keep the security info with the
+``--keep-security-info`` option.
+
+Always first use ``--dry-run --list`` to see what would be deleted.
\ No newline at end of file
diff --git a/docs/usage/recreate.rst b/docs/usage/recreate.rst
index 5ff2917fd..7f520acf2 100644
--- a/docs/usage/recreate.rst
+++ b/docs/usage/recreate.rst
@@ -4,30 +4,25 @@ Examples
 ~~~~~~~~
 ::
 
-    # Make old (Attic / Borg 0.xx) archives deduplicate with Borg 1.x archives.
-    # Archives created with Borg 1.1+ and the default chunker params are skipped
-    # (archive ID stays the same).
-    $ borg recreate /mnt/backup --chunker-params default --progress
-
     # Create a backup with little but fast compression
-    $ borg create /mnt/backup::archive /some/files --compression lz4
+    $ borg create archive /some/files --compression lz4
     # Then compress it - this might take longer, but the backup has already completed,
     # so no inconsistencies from a long-running backup job.
-    $ borg recreate /mnt/backup::archive --recompress --compression zlib,9
+    $ borg recreate -a archive --recompress --compression zlib,9
 
     # Remove unwanted files from all archives in a repository.
     # Note the relative path for the --exclude option - archives only contain relative paths.
-    $ borg recreate /mnt/backup --exclude home/icke/Pictures/drunk_photos
+    $ borg recreate --exclude home/icke/Pictures/drunk_photos
 
     # Change archive comment
-    $ borg create --comment "This is a comment" /mnt/backup::archivename ~
-    $ borg info /mnt/backup::archivename
+    $ borg create --comment "This is a comment" archivename ~
+    $ borg info -a archivename
     Name: archivename
     Fingerprint: ...
     Comment: This is a comment
     ...
-    $ borg recreate --comment "This is a better comment" /mnt/backup::archivename
-    $ borg info /mnt/backup::archivename
+    $ borg recreate --comment "This is a better comment" -a archivename
+    $ borg info -a archivename
     Name: archivename
     Fingerprint: ...
     Comment: This is a better comment
diff --git a/docs/usage/recreate.rst.inc b/docs/usage/recreate.rst.inc
index f64e07599..40dd7b1fe 100644
--- a/docs/usage/recreate.rst.inc
+++ b/docs/usage/recreate.rst.inc
@@ -6,65 +6,73 @@ borg recreate
 -------------
 .. code-block:: none
 
-    borg [common options] recreate [options] [REPOSITORY_OR_ARCHIVE] [PATH...]
+    borg [common options] recreate [options] [PATH...]
 
 .. only:: html
 
     .. class:: borg-options-table
 
-    +-------------------------------------------------------+---------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-    | **positional arguments**                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
-    +-------------------------------------------------------+---------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-    |                                                       | ``REPOSITORY_OR_ARCHIVE``                         | repository or archive to recreate                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
-    +-------------------------------------------------------+---------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-    |                                                       | ``PATH``                                          | paths to recreate; patterns are supported                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
-    +-------------------------------------------------------+---------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-    | **optional arguments**                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
-    +-------------------------------------------------------+---------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-    |                                                       | ``--list``                                        | output verbose list of items (files, dirs, ...)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
-    +-------------------------------------------------------+---------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-    |                                                       | ``--filter STATUSCHARS``                          | only display items with the given status characters (listed in borg create --help)                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
-    +-------------------------------------------------------+---------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-    |                                                       | ``-n``, ``--dry-run``                             | do not change anything                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
-    +-------------------------------------------------------+---------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-    |                                                       | ``-s``, ``--stats``                               | print statistics at end                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
-    +-------------------------------------------------------+---------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-    | .. class:: borg-common-opt-ref                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
-    |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
-    | :ref:`common_options`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
-    +-------------------------------------------------------+---------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-    | **Exclusion options**                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
-    +-------------------------------------------------------+---------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-    |                                                       | ``-e PATTERN``, ``--exclude PATTERN``             | exclude paths matching PATTERN                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
-    +-------------------------------------------------------+---------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-    |                                                       | ``--exclude-from EXCLUDEFILE``                    | read exclude patterns from EXCLUDEFILE, one per line                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
-    +-------------------------------------------------------+---------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-    |                                                       | ``--pattern PATTERN``                             | include/exclude paths matching PATTERN                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
-    +-------------------------------------------------------+---------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-    |                                                       | ``--patterns-from PATTERNFILE``                   | read include/exclude patterns from PATTERNFILE, one per line                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
-    +-------------------------------------------------------+---------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-    |                                                       | ``--exclude-caches``                              | exclude directories that contain a CACHEDIR.TAG file (http://www.bford.info/cachedir/spec.html)                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
-    +-------------------------------------------------------+---------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-    |                                                       | ``--exclude-if-present NAME``                     | exclude directories that are tagged by containing a filesystem object with the given NAME                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
-    +-------------------------------------------------------+---------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-    |                                                       | ``--keep-exclude-tags``                           | if tag objects are specified with ``--exclude-if-present``, don't omit the tag objects themselves from the backup archive                                                                                                                                                                                                                                                                                                                                                                                                                                   |
-    +-------------------------------------------------------+---------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-    | **Archive options**                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
-    +-------------------------------------------------------+---------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-    |                                                       | ``--target TARGET``                               | create a new archive with the name ARCHIVE, do not replace existing archive (only applies for a single archive)                                                                                                                                                                                                                                                                                                                                                                                                                                             |
-    +-------------------------------------------------------+---------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-    |                                                       | ``-c SECONDS``, ``--checkpoint-interval SECONDS`` | write checkpoint every SECONDS seconds (Default: 1800)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
-    +-------------------------------------------------------+---------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-    |                                                       | ``--comment COMMENT``                             | add a comment text to the archive                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
-    +-------------------------------------------------------+---------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-    |                                                       | ``--timestamp TIMESTAMP``                         | manually specify the archive creation date/time (UTC, yyyy-mm-ddThh:mm:ss format). alternatively, give a reference file/directory.                                                                                                                                                                                                                                                                                                                                                                                                                          |
-    +-------------------------------------------------------+---------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-    |                                                       | ``-C COMPRESSION``, ``--compression COMPRESSION`` | select compression algorithm, see the output of the "borg help compression" command for details.                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
-    +-------------------------------------------------------+---------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-    |                                                       | ``--recompress MODE``                             | recompress data chunks according to `MODE` and ``--compression``. Possible modes are `if-different`: recompress if current compression is with a different compression algorithm (the level is not considered); `always`: recompress even if current compression is with the same compression algorithm (use this to change the compression level); and `never`: do not recompress (use this option to explicitly prevent recompression). If no MODE is given, `if-different` will be used. Not passing --recompress is equivalent to "--recompress never". |
-    +-------------------------------------------------------+---------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-    |                                                       | ``--chunker-params PARAMS``                       | specify the chunker parameters (ALGO, CHUNK_MIN_EXP, CHUNK_MAX_EXP, HASH_MASK_BITS, HASH_WINDOW_SIZE) or `default` to use the current defaults. default: buzhash,19,23,21,4095                                                                                                                                                                                                                                                                                                                                                                              |
-    +-------------------------------------------------------+---------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+    +-----------------------------------------------------------------------------+---------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+    | **positional arguments**                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
+    +-----------------------------------------------------------------------------+---------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+    |                                                                             | ``PATH``                                          | paths to recreate; patterns are supported                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
+    +-----------------------------------------------------------------------------+---------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+    | **optional arguments**                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
+    +-----------------------------------------------------------------------------+---------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+    |                                                                             | ``--list``                                        | output verbose list of items (files, dirs, ...)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
+    +-----------------------------------------------------------------------------+---------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+    |                                                                             | ``--filter STATUSCHARS``                          | only display items with the given status characters (listed in borg create --help)                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
+    +-----------------------------------------------------------------------------+---------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+    |                                                                             | ``-n``, ``--dry-run``                             | do not change anything                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
+    +-----------------------------------------------------------------------------+---------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+    |                                                                             | ``-s``, ``--stats``                               | print statistics at end                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
+    +-----------------------------------------------------------------------------+---------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+    | .. class:: borg-common-opt-ref                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
+    |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
+    | :ref:`common_options`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+    +-----------------------------------------------------------------------------+---------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+    | **Exclusion options**                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+    +-----------------------------------------------------------------------------+---------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+    |                                                                             | ``-e PATTERN``, ``--exclude PATTERN``             | exclude paths matching PATTERN                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
+    +-----------------------------------------------------------------------------+---------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+    |                                                                             | ``--exclude-from EXCLUDEFILE``                    | read exclude patterns from EXCLUDEFILE, one per line                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
+    +-----------------------------------------------------------------------------+---------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+    |                                                                             | ``--pattern PATTERN``                             | include/exclude paths matching PATTERN                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
+    +-----------------------------------------------------------------------------+---------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+    |                                                                             | ``--patterns-from PATTERNFILE``                   | read include/exclude patterns from PATTERNFILE, one per line                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
+    +-----------------------------------------------------------------------------+---------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+    |                                                                             | ``--exclude-caches``                              | exclude directories that contain a CACHEDIR.TAG file (http://www.bford.info/cachedir/spec.html)                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
+    +-----------------------------------------------------------------------------+---------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+    |                                                                             | ``--exclude-if-present NAME``                     | exclude directories that are tagged by containing a filesystem object with the given NAME                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
+    +-----------------------------------------------------------------------------+---------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+    |                                                                             | ``--keep-exclude-tags``                           | if tag objects are specified with ``--exclude-if-present``, don't omit the tag objects themselves from the backup archive                                                                                                                                                                                                                                                                                                                                                                                                                                   |
+    +-----------------------------------------------------------------------------+---------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+    | **Archive filters** — Archive filters can be applied to repository targets.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
+    +-----------------------------------------------------------------------------+---------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+    |                                                                             | ``-P PREFIX``, ``--prefix PREFIX``                | only consider archive names starting with this prefix.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
+    +-----------------------------------------------------------------------------+---------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+    |                                                                             | ``-a GLOB``, ``--glob-archives GLOB``             | only consider archive names matching the glob. sh: rules apply, see "borg help patterns". ``--prefix`` and ``--glob-archives`` are mutually exclusive.                                                                                                                                                                                                                                                                                                                                                                                                      |
+    +-----------------------------------------------------------------------------+---------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+    |                                                                             | ``--sort-by KEYS``                                | Comma-separated list of sorting keys; valid keys are: timestamp, name, id; default is: timestamp                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
+    +-----------------------------------------------------------------------------+---------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+    |                                                                             | ``--first N``                                     | consider first N archives after other filters were applied                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
+    +-----------------------------------------------------------------------------+---------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+    |                                                                             | ``--last N``                                      | consider last N archives after other filters were applied                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
+    +-----------------------------------------------------------------------------+---------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+    |                                                                             | ``--target TARGET``                               | create a new archive with the name ARCHIVE, do not replace existing archive (only applies for a single archive)                                                                                                                                                                                                                                                                                                                                                                                                                                             |
+    +-----------------------------------------------------------------------------+---------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+    |                                                                             | ``-c SECONDS``, ``--checkpoint-interval SECONDS`` | write checkpoint every SECONDS seconds (Default: 1800)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
+    +-----------------------------------------------------------------------------+---------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+    |                                                                             | ``--comment COMMENT``                             | add a comment text to the archive                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
+    +-----------------------------------------------------------------------------+---------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+    |                                                                             | ``--timestamp TIMESTAMP``                         | manually specify the archive creation date/time (UTC, yyyy-mm-ddThh:mm:ss format). alternatively, give a reference file/directory.                                                                                                                                                                                                                                                                                                                                                                                                                          |
+    +-----------------------------------------------------------------------------+---------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+    |                                                                             | ``-C COMPRESSION``, ``--compression COMPRESSION`` | select compression algorithm, see the output of the "borg help compression" command for details.                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
+    +-----------------------------------------------------------------------------+---------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+    |                                                                             | ``--recompress MODE``                             | recompress data chunks according to `MODE` and ``--compression``. Possible modes are `if-different`: recompress if current compression is with a different compression algorithm (the level is not considered); `always`: recompress even if current compression is with the same compression algorithm (use this to change the compression level); and `never`: do not recompress (use this option to explicitly prevent recompression). If no MODE is given, `if-different` will be used. Not passing --recompress is equivalent to "--recompress never". |
+    +-----------------------------------------------------------------------------+---------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+    |                                                                             | ``--chunker-params PARAMS``                       | specify the chunker parameters (ALGO, CHUNK_MIN_EXP, CHUNK_MAX_EXP, HASH_MASK_BITS, HASH_WINDOW_SIZE) or `default` to use the current defaults. default: buzhash,19,23,21,4095                                                                                                                                                                                                                                                                                                                                                                              |
+    +-----------------------------------------------------------------------------+---------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
 
     .. raw:: html
 
@@ -76,8 +84,6 @@ borg recreate
 
 .. only:: latex
 
-    REPOSITORY_OR_ARCHIVE
-        repository or archive to recreate
     PATH
         paths to recreate; patterns are supported
 
@@ -102,7 +108,12 @@ borg recreate
         --keep-exclude-tags               if tag objects are specified with ``--exclude-if-present``, don't omit the tag objects themselves from the backup archive
 
 
-    Archive options
+    Archive filters
+        -P PREFIX, --prefix PREFIX                    only consider archive names starting with this prefix.
+        -a GLOB, --glob-archives GLOB                 only consider archive names matching the glob. sh: rules apply, see "borg help patterns". ``--prefix`` and ``--glob-archives`` are mutually exclusive.
+        --sort-by KEYS                                Comma-separated list of sorting keys; valid keys are: timestamp, name, id; default is: timestamp
+        --first N                                     consider first N archives after other filters were applied
+        --last N                                      consider last N archives after other filters were applied
         --target TARGET                               create a new archive with the name ARCHIVE, do not replace existing archive (only applies for a single archive)
         -c SECONDS, --checkpoint-interval SECONDS     write checkpoint every SECONDS seconds (Default: 1800)
         --comment COMMENT                             add a comment text to the archive
diff --git a/docs/usage/rename.rst b/docs/usage/rename.rst
index 456e8fca7..a4a9bc9ee 100644
--- a/docs/usage/rename.rst
+++ b/docs/usage/rename.rst
@@ -4,10 +4,10 @@ Examples
 ~~~~~~~~
 ::
 
-    $ borg create /path/to/repo::archivename ~
-    $ borg list /path/to/repo
+    $ borg create archivename ~
+    $ borg rlist
     archivename                          Mon, 2016-02-15 19:50:19
 
-    $ borg rename /path/to/repo::archivename newname
-    $ borg list /path/to/repo
+    $ borg rename archivename newname
+    $ borg rlist
     newname                              Mon, 2016-02-15 19:50:19
diff --git a/docs/usage/rename.rst.inc b/docs/usage/rename.rst.inc
index e68c7f78e..96cb62066 100644
--- a/docs/usage/rename.rst.inc
+++ b/docs/usage/rename.rst.inc
@@ -6,23 +6,23 @@ borg rename
 -----------
 .. code-block:: none
 
-    borg [common options] rename [options] ARCHIVE NEWNAME
+    borg [common options] rename [options] OLDNAME NEWNAME
 
 .. only:: html
 
     .. class:: borg-options-table
 
-    +-------------------------------------------------------+-------------+-----------------------------+
-    | **positional arguments**                                                                          |
-    +-------------------------------------------------------+-------------+-----------------------------+
-    |                                                       | ``ARCHIVE`` | archive to rename           |
-    +-------------------------------------------------------+-------------+-----------------------------+
-    |                                                       | ``NEWNAME`` | the new archive name to use |
-    +-------------------------------------------------------+-------------+-----------------------------+
-    | .. class:: borg-common-opt-ref                                                                    |
-    |                                                                                                   |
-    | :ref:`common_options`                                                                             |
-    +-------------------------------------------------------+-------------+-----------------------------+
+    +-------------------------------------------------------+-------------+------------------------------+
+    | **positional arguments**                                                                           |
+    +-------------------------------------------------------+-------------+------------------------------+
+    |                                                       | ``OLDNAME`` | specify the archive name     |
+    +-------------------------------------------------------+-------------+------------------------------+
+    |                                                       | ``NEWNAME`` | specify the new archive name |
+    +-------------------------------------------------------+-------------+------------------------------+
+    | .. class:: borg-common-opt-ref                                                                     |
+    |                                                                                                    |
+    | :ref:`common_options`                                                                              |
+    +-------------------------------------------------------+-------------+------------------------------+
 
     .. raw:: html
 
@@ -34,10 +34,10 @@ borg rename
 
 .. only:: latex
 
-    ARCHIVE
-        archive to rename
+    OLDNAME
+        specify the archive name
     NEWNAME
-        the new archive name to use
+        specify the new archive name
 
 
     :ref:`common_options`
diff --git a/docs/usage/rinfo.rst b/docs/usage/rinfo.rst
new file mode 100644
index 000000000..0b1097207
--- /dev/null
+++ b/docs/usage/rinfo.rst
@@ -0,0 +1,16 @@
+.. include:: rinfo.rst.inc
+
+Examples
+~~~~~~~~
+::
+
+    $ borg rinfo
+    Repository ID: 0e85a7811022326c067acb2a7181d5b526b7d2f61b34470fb8670c440a67f1a9
+    Location: /Users/tw/w/borg/path/to/repo
+    Encrypted: Yes (repokey AES-OCB)
+    Cache: /Users/tw/.cache/borg/0e85a7811022326c067acb2a7181d5b526b7d2f61b34470fb8670c440a67f1a9
+    Security dir: /Users/tw/.config/borg/security/0e85a7811022326c067acb2a7181d5b526b7d2f61b34470fb8670c440a67f1a9
+    Original size: 152.14 MB
+    Deduplicated size: 30.38 MB
+    Unique chunks: 654
+    Total chunks: 3302
diff --git a/docs/usage/rinfo.rst.inc b/docs/usage/rinfo.rst.inc
new file mode 100644
index 000000000..fa57cdebd
--- /dev/null
+++ b/docs/usage/rinfo.rst.inc
@@ -0,0 +1,56 @@
+.. IMPORTANT: this file is auto-generated from borg's built-in help, do not edit!
+
+.. _borg_rinfo:
+
+borg rinfo
+----------
+.. code-block:: none
+
+    borg [common options] rinfo [options]
+
+.. only:: html
+
+    .. class:: borg-options-table
+
+    +-------------------------------------------------------+------------+-----------------------+
+    | **optional arguments**                                                                     |
+    +-------------------------------------------------------+------------+-----------------------+
+    |                                                       | ``--json`` | format output as JSON |
+    +-------------------------------------------------------+------------+-----------------------+
+    | .. class:: borg-common-opt-ref                                                             |
+    |                                                                                            |
+    | :ref:`common_options`                                                                      |
+    +-------------------------------------------------------+------------+-----------------------+
+
+    .. raw:: html
+
+        <script type='text/javascript'>
+        $(document).ready(function () {
+            $('.borg-options-table colgroup').remove();
+        })
+        </script>
+
+.. only:: latex
+
+
+
+    optional arguments
+        --json     format output as JSON
+
+
+    :ref:`common_options`
+        |
+
+Description
+~~~~~~~~~~~
+
+This command displays detailed information about the repository.
+
+Please note that the deduplicated sizes of the individual archives do not add
+up to the deduplicated size of the repository ("all archives"), because the two
+are meaning different things:
+
+This archive / deduplicated size = amount of data stored ONLY for this archive
+= unique chunks of this archive.
+All archives / deduplicated size = amount of data stored in the repo
+= all chunks in the repository.
\ No newline at end of file
diff --git a/docs/usage/rlist.rst b/docs/usage/rlist.rst
new file mode 100644
index 000000000..47bb2a6d7
--- /dev/null
+++ b/docs/usage/rlist.rst
@@ -0,0 +1,13 @@
+.. include:: rlist.rst.inc
+
+Examples
+~~~~~~~~
+::
+
+    $ borg rlist
+    Monday                               Mon, 2016-02-15 19:15:11
+    repo                                 Mon, 2016-02-15 19:26:54
+    root-2016-02-15                      Mon, 2016-02-15 19:36:29
+    newname                              Mon, 2016-02-15 19:50:19
+    ...
+
diff --git a/docs/usage/rlist.rst.inc b/docs/usage/rlist.rst.inc
new file mode 100644
index 000000000..335fc629d
--- /dev/null
+++ b/docs/usage/rlist.rst.inc
@@ -0,0 +1,125 @@
+.. IMPORTANT: this file is auto-generated from borg's built-in help, do not edit!
+
+.. _borg_rlist:
+
+borg rlist
+----------
+.. code-block:: none
+
+    borg [common options] rlist [options]
+
+.. only:: html
+
+    .. class:: borg-options-table
+
+    +-----------------------------------------------------------------------------+---------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+    | **optional arguments**                                                                                                                                                                                                                                                                                                                             |
+    +-----------------------------------------------------------------------------+---------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+    |                                                                             | ``--consider-checkpoints``            | Show checkpoint archives in the repository contents list (default: hidden).                                                                                                                                                  |
+    +-----------------------------------------------------------------------------+---------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+    |                                                                             | ``--short``                           | only print the archive names, nothing else                                                                                                                                                                                   |
+    +-----------------------------------------------------------------------------+---------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+    |                                                                             | ``--format FORMAT``                   | specify format for archive listing (default: "{archive:<36} {time} [{id}]{NL}")                                                                                                                                              |
+    +-----------------------------------------------------------------------------+---------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+    |                                                                             | ``--json``                            | Format output as JSON. The form of ``--format`` is ignored, but keys used in it are added to the JSON output. Some keys are always present. Note: JSON can only represent text. A "barchive" key is therefore not available. |
+    +-----------------------------------------------------------------------------+---------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+    | .. class:: borg-common-opt-ref                                                                                                                                                                                                                                                                                                                     |
+    |                                                                                                                                                                                                                                                                                                                                                    |
+    | :ref:`common_options`                                                                                                                                                                                                                                                                                                                              |
+    +-----------------------------------------------------------------------------+---------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+    | **Archive filters** — Archive filters can be applied to repository targets.                                                                                                                                                                                                                                                                        |
+    +-----------------------------------------------------------------------------+---------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+    |                                                                             | ``-P PREFIX``, ``--prefix PREFIX``    | only consider archive names starting with this prefix.                                                                                                                                                                       |
+    +-----------------------------------------------------------------------------+---------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+    |                                                                             | ``-a GLOB``, ``--glob-archives GLOB`` | only consider archive names matching the glob. sh: rules apply, see "borg help patterns". ``--prefix`` and ``--glob-archives`` are mutually exclusive.                                                                       |
+    +-----------------------------------------------------------------------------+---------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+    |                                                                             | ``--sort-by KEYS``                    | Comma-separated list of sorting keys; valid keys are: timestamp, name, id; default is: timestamp                                                                                                                             |
+    +-----------------------------------------------------------------------------+---------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+    |                                                                             | ``--first N``                         | consider first N archives after other filters were applied                                                                                                                                                                   |
+    +-----------------------------------------------------------------------------+---------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+    |                                                                             | ``--last N``                          | consider last N archives after other filters were applied                                                                                                                                                                    |
+    +-----------------------------------------------------------------------------+---------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+
+    .. raw:: html
+
+        <script type='text/javascript'>
+        $(document).ready(function () {
+            $('.borg-options-table colgroup').remove();
+        })
+        </script>
+
+.. only:: latex
+
+
+
+    optional arguments
+        --consider-checkpoints    Show checkpoint archives in the repository contents list (default: hidden).
+        --short     only print the archive names, nothing else
+        --format FORMAT    specify format for archive listing (default: "{archive:<36} {time} [{id}]{NL}")
+        --json      Format output as JSON. The form of ``--format`` is ignored, but keys used in it are added to the JSON output. Some keys are always present. Note: JSON can only represent text. A "barchive" key is therefore not available.
+
+
+    :ref:`common_options`
+        |
+
+    Archive filters
+        -P PREFIX, --prefix PREFIX        only consider archive names starting with this prefix.
+        -a GLOB, --glob-archives GLOB     only consider archive names matching the glob. sh: rules apply, see "borg help patterns". ``--prefix`` and ``--glob-archives`` are mutually exclusive.
+        --sort-by KEYS                    Comma-separated list of sorting keys; valid keys are: timestamp, name, id; default is: timestamp
+        --first N                         consider first N archives after other filters were applied
+        --last N                          consider last N archives after other filters were applied
+
+
+Description
+~~~~~~~~~~~
+
+This command lists the archives contained in a repository.
+
+.. man NOTES
+
+The FORMAT specifier syntax
++++++++++++++++++++++++++++
+
+The ``--format`` option uses python's `format string syntax
+<https://docs.python.org/3.9/library/string.html#formatstrings>`_.
+
+Examples:
+::
+
+    $ borg rlist --format '{archive}{NL}'
+    ArchiveFoo
+    ArchiveBar
+    ...
+
+    # {VAR:NUMBER} - pad to NUMBER columns.
+    # Strings are left-aligned, numbers are right-aligned.
+    # Note: time columns except ``isomtime``, ``isoctime`` and ``isoatime`` cannot be padded.
+    $ borg rlist --format '{archive:36} {time} [{id}]{NL}' /path/to/repo
+    ArchiveFoo                           Thu, 2021-12-09 10:22:28 [0b8e9a312bef3f2f6e2d0fc110c196827786c15eba0188738e81697a7fa3b274]
+    ...
+
+The following keys are always available:
+- NEWLINE: OS dependent line separator
+- NL: alias of NEWLINE
+- NUL: NUL character for creating print0 / xargs -0 like output, see barchive and bpath keys below
+- SPACE
+- TAB
+- CR
+- LF
+
+Keys available only when listing archives in a repository:
+
+- archive: archive name interpreted as text (might be missing non-text characters, see barchive)
+- name: alias of "archive"
+- barchive: verbatim archive name, can contain any character except NUL
+- comment: archive comment interpreted as text (might be missing non-text characters, see bcomment)
+- bcomment: verbatim archive comment, can contain any character except NUL
+- id: internal ID of the archive
+
+- start: time (start) of creation of the archive
+- time: alias of "start"
+- end: time (end) of creation of the archive
+- command_line: command line which was used to create the archive
+
+- hostname: hostname of host on which this archive was created
+- username: username of user who created this archive
diff --git a/docs/usage/tar.rst b/docs/usage/tar.rst
index ed1dcc0a6..63a3aff0d 100644
--- a/docs/usage/tar.rst
+++ b/docs/usage/tar.rst
@@ -7,25 +7,25 @@ Examples
 ::
 
     # export as uncompressed tar
-    $ borg export-tar /path/to/repo::Monday Monday.tar
+    $ borg export-tar Monday Monday.tar
 
     # import an uncompressed tar
-    $ borg import-tar /path/to/repo::Monday Monday.tar
+    $ borg import-tar Monday Monday.tar
 
     # exclude some file types, compress using gzip
-    $ borg export-tar /path/to/repo::Monday Monday.tar.gz --exclude '*.so'
+    $ borg export-tar Monday Monday.tar.gz --exclude '*.so'
 
     # use higher compression level with gzip
-    $ borg export-tar --tar-filter="gzip -9" repo::Monday Monday.tar.gz
+    $ borg export-tar --tar-filter="gzip -9" Monday Monday.tar.gz
 
     # copy an archive from repoA to repoB
-    $ borg export-tar --tar-format=BORG repoA::archive - | borg import-tar repoB::archive -
+    $ borg -r repoA export-tar --tar-format=BORG archive - | borg -r repoB import-tar archive -
 
     # export a tar, but instead of storing it on disk, upload it to remote site using curl
-    $ borg export-tar /path/to/repo::Monday - | curl --data-binary @- https://somewhere/to/POST
+    $ borg export-tar Monday - | curl --data-binary @- https://somewhere/to/POST
 
     # remote extraction via "tarpipe"
-    $ borg export-tar /path/to/repo::Monday - | ssh somewhere "cd extracted; tar x"
+    $ borg export-tar Monday - | ssh somewhere "cd extracted; tar x"
 
 Archives transfer script
 ~~~~~~~~~~~~~~~~~~~~~~~~
@@ -34,9 +34,9 @@ Outputs a script that copies all archives from repo1 to repo2:
 
 ::
 
-    for A T in `borg list --format='{archive} {time:%Y-%m-%dT%H:%M:%S}{LF}' repo1`
+    for A T in `borg list --format='{archive} {time:%Y-%m-%dT%H:%M:%S}{LF}'`
     do
-      echo "borg export-tar --tar-format=BORG repo1::$A - | borg import-tar --timestamp=$T repo2::$A -"
+      echo "borg -r repo1 export-tar --tar-format=BORG $A - | borg -r repo2 import-tar --timestamp=$T $A -"
     done
 
 Kept:
diff --git a/docs/usage/transfer.rst b/docs/usage/transfer.rst
new file mode 100644
index 000000000..4d9f1998a
--- /dev/null
+++ b/docs/usage/transfer.rst
@@ -0,0 +1 @@
+.. include:: transfer.rst.inc
diff --git a/docs/usage/transfer.rst.inc b/docs/usage/transfer.rst.inc
new file mode 100644
index 000000000..838a7074e
--- /dev/null
+++ b/docs/usage/transfer.rst.inc
@@ -0,0 +1,87 @@
+.. IMPORTANT: this file is auto-generated from borg's built-in help, do not edit!
+
+.. _borg_transfer:
+
+borg transfer
+-------------
+.. code-block:: none
+
+    borg [common options] transfer [options]
+
+.. only:: html
+
+    .. class:: borg-options-table
+
+    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------+
+    | **optional arguments**                                                                                                                                                                                                                                                       |
+    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------+
+    |                                                                             | ``-n``, ``--dry-run``                 | do not change repository, just check                                                                                                                   |
+    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------+
+    |                                                                             | ``--other-repo SRC_REPOSITORY``       | transfer archives from the other repository                                                                                                            |
+    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------+
+    | .. class:: borg-common-opt-ref                                                                                                                                                                                                                                               |
+    |                                                                                                                                                                                                                                                                              |
+    | :ref:`common_options`                                                                                                                                                                                                                                                        |
+    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------+
+    | **Archive filters** — Archive filters can be applied to repository targets.                                                                                                                                                                                                  |
+    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------+
+    |                                                                             | ``-P PREFIX``, ``--prefix PREFIX``    | only consider archive names starting with this prefix.                                                                                                 |
+    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------+
+    |                                                                             | ``-a GLOB``, ``--glob-archives GLOB`` | only consider archive names matching the glob. sh: rules apply, see "borg help patterns". ``--prefix`` and ``--glob-archives`` are mutually exclusive. |
+    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------+
+    |                                                                             | ``--sort-by KEYS``                    | Comma-separated list of sorting keys; valid keys are: timestamp, name, id; default is: timestamp                                                       |
+    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------+
+    |                                                                             | ``--first N``                         | consider first N archives after other filters were applied                                                                                             |
+    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------+
+    |                                                                             | ``--last N``                          | consider last N archives after other filters were applied                                                                                              |
+    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------+
+
+    .. raw:: html
+
+        <script type='text/javascript'>
+        $(document).ready(function () {
+            $('.borg-options-table colgroup').remove();
+        })
+        </script>
+
+.. only:: latex
+
+
+
+    optional arguments
+        -n, --dry-run     do not change repository, just check
+        --other-repo SRC_REPOSITORY    transfer archives from the other repository
+
+
+    :ref:`common_options`
+        |
+
+    Archive filters
+        -P PREFIX, --prefix PREFIX        only consider archive names starting with this prefix.
+        -a GLOB, --glob-archives GLOB     only consider archive names matching the glob. sh: rules apply, see "borg help patterns". ``--prefix`` and ``--glob-archives`` are mutually exclusive.
+        --sort-by KEYS                    Comma-separated list of sorting keys; valid keys are: timestamp, name, id; default is: timestamp
+        --first N                         consider first N archives after other filters were applied
+        --last N                          consider last N archives after other filters were applied
+
+
+Description
+~~~~~~~~~~~
+
+This command transfers archives from one repository to another repository.
+
+Suggested use::
+
+    # initialize DST_REPO reusing key material from SRC_REPO, so that
+    # chunking and chunk id generation will work in the same way as before.
+    borg --repo=DST_REPO init --other-repo=SRC_REPO --encryption=DST_ENC
+
+    # transfer archives from SRC_REPO to DST_REPO
+    borg --repo=DST_REPO transfer --other-repo=SRC_REPO --dry-run  # check what it would do
+    borg --repo=DST_REPO transfer --other-repo=SRC_REPO            # do it!
+    borg --repo=DST_REPO transfer --other-repo=SRC_REPO --dry-run  # check! anything left?
+
+The default is to transfer all archives, including checkpoint archives.
+
+You could use the misc. archive filter options to limit which archives it will
+transfer, e.g. using the -a option. This is recommended for big
+repositories with multiple data sets to keep the runtime per invocation lower.
\ No newline at end of file
diff --git a/docs/usage/upgrade.rst.inc b/docs/usage/upgrade.rst.inc
index c07b73093..f1cd806ef 100644
--- a/docs/usage/upgrade.rst.inc
+++ b/docs/usage/upgrade.rst.inc
@@ -6,16 +6,12 @@ borg upgrade
 ------------
 .. code-block:: none
 
-    borg [common options] upgrade [options] [REPOSITORY]
+    borg [common options] upgrade [options]
 
 .. only:: html
 
     .. class:: borg-options-table
 
-    +-------------------------------------------------------+-----------------------+------------------------------------------------------------------------------------------------+
-    | **positional arguments**                                                                                                                                                       |
-    +-------------------------------------------------------+-----------------------+------------------------------------------------------------------------------------------------+
-    |                                                       | ``REPOSITORY``        | path to the repository to be upgraded                                                          |
     +-------------------------------------------------------+-----------------------+------------------------------------------------------------------------------------------------+
     | **optional arguments**                                                                                                                                                         |
     +-------------------------------------------------------+-----------------------+------------------------------------------------------------------------------------------------+
@@ -44,8 +40,6 @@ borg upgrade
 
 .. only:: latex
 
-    REPOSITORY
-        path to the repository to be upgraded
 
 
     optional arguments
diff --git a/docs/usage/with-lock.rst.inc b/docs/usage/with-lock.rst.inc
index 6f4fc741a..203e36cb8 100644
--- a/docs/usage/with-lock.rst.inc
+++ b/docs/usage/with-lock.rst.inc
@@ -6,25 +6,23 @@ borg with-lock
 --------------
 .. code-block:: none
 
-    borg [common options] with-lock [options] REPOSITORY COMMAND [ARGS...]
+    borg [common options] with-lock [options] COMMAND [ARGS...]
 
 .. only:: html
 
     .. class:: borg-options-table
 
-    +-------------------------------------------------------+----------------+--------------------+
-    | **positional arguments**                                                                    |
-    +-------------------------------------------------------+----------------+--------------------+
-    |                                                       | ``REPOSITORY`` | repository to lock |
-    +-------------------------------------------------------+----------------+--------------------+
-    |                                                       | ``COMMAND``    | command to run     |
-    +-------------------------------------------------------+----------------+--------------------+
-    |                                                       | ``ARGS``       | command arguments  |
-    +-------------------------------------------------------+----------------+--------------------+
-    | .. class:: borg-common-opt-ref                                                              |
-    |                                                                                             |
-    | :ref:`common_options`                                                                       |
-    +-------------------------------------------------------+----------------+--------------------+
+    +-------------------------------------------------------+-------------+-------------------+
+    | **positional arguments**                                                                |
+    +-------------------------------------------------------+-------------+-------------------+
+    |                                                       | ``COMMAND`` | command to run    |
+    +-------------------------------------------------------+-------------+-------------------+
+    |                                                       | ``ARGS``    | command arguments |
+    +-------------------------------------------------------+-------------+-------------------+
+    | .. class:: borg-common-opt-ref                                                          |
+    |                                                                                         |
+    | :ref:`common_options`                                                                   |
+    +-------------------------------------------------------+-------------+-------------------+
 
     .. raw:: html
 
@@ -36,8 +34,6 @@ borg with-lock
 
 .. only:: latex
 
-    REPOSITORY
-        repository to lock
     COMMAND
         command to run
     ARGS
diff --git a/src/borg/archiver.py b/src/borg/archiver.py
index 8218ca1cf..7bcd082e2 100644
--- a/src/borg/archiver.py
+++ b/src/borg/archiver.py
@@ -2634,21 +2634,21 @@ class Archiver:
         Examples::
 
             # Exclude '/home/user/file.o' but not '/home/user/file.odt':
-            $ borg create -e '*.o' /path/to/repo::archive /
+            $ borg create -e '*.o' archive /
 
             # Exclude '/home/user/junk' and '/home/user/subdir/junk' but
             # not '/home/user/importantjunk' or '/etc/junk':
-            $ borg create -e 'home/*/junk' /path/to/repo::archive /
+            $ borg create -e 'home/*/junk' archive /
 
             # Exclude the contents of '/home/user/cache' but not the directory itself:
-            $ borg create -e home/user/cache/ /path/to/repo::archive /
+            $ borg create -e home/user/cache/ archive /
 
             # The file '/home/user/cache/important' is *not* backed up:
-            $ borg create -e home/user/cache/ /path/to/repo::archive / /home/user/cache/important
+            $ borg create -e home/user/cache/ archive / /home/user/cache/important
 
             # The contents of directories in '/home' are not backed up when their name
             # ends in '.tmp'
-            $ borg create --exclude 're:^home/[^/]+\\.tmp/' /path/to/repo::archive /
+            $ borg create --exclude 're:^home/[^/]+\\.tmp/' archive /
 
             # Load exclusions from file
             $ cat >exclude.txt <<EOF
@@ -2661,7 +2661,7 @@ class Archiver:
             # Example with spaces, no need to escape as it is processed by borg
             some file with spaces.txt
             EOF
-            $ borg create --exclude-from exclude.txt /path/to/repo::archive /
+            $ borg create --exclude-from exclude.txt archive /
 
         A more general and easier to use way to define filename matching patterns
         exists with the ``--pattern`` and ``--patterns-from`` options. Using
@@ -2700,7 +2700,7 @@ class Archiver:
 
         **Tip: You can easily test your patterns with --dry-run and  --list**::
 
-            $ borg create --dry-run --list --patterns-from patterns.txt /path/to/repo::archive
+            $ borg create --dry-run --list --patterns-from patterns.txt archive
 
         This will list the considered files one per line, prefixed with a
         character that indicates the action (e.g. 'x' for excluding, see
@@ -2720,16 +2720,16 @@ class Archiver:
 
             # backup pics, but not the ones from 2018, except the good ones:
             # note: using = is essential to avoid cmdline argument parsing issues.
-            borg create --pattern=+pics/2018/good --pattern=-pics/2018 /path/to/repo::archive pics
+            borg create --pattern=+pics/2018/good --pattern=-pics/2018 archive pics
 
             # backup only JPG/JPEG files (case insensitive) in all home directories:
-            borg create --pattern '+ re:\\.jpe?g(?i)$' /path/to/repo::archive /home
+            borg create --pattern '+ re:\\.jpe?g(?i)$' archive /home
 
             # backup homes, but exclude big downloads (like .ISO files) or hidden files:
-            borg create --exclude 're:\\.iso(?i)$' --exclude 'sh:home/**/.*' /path/to/repo::archive /home
+            borg create --exclude 're:\\.iso(?i)$' --exclude 'sh:home/**/.*' archive /home
 
             # use a file with patterns (recursion root '/' via command line):
-            borg create --patterns-from patterns.lst /path/to/repo::archive /
+            borg create --patterns-from patterns.lst archive /
 
         The patterns.lst file could look like that::
 
@@ -2748,8 +2748,8 @@ class Archiver:
         You can specify recursion roots either on the command line or in a patternfile::
 
             # these two commands do the same thing
-            borg create --exclude home/bobby/junk /path/to/repo::archive /home/bobby /home/susan
-            borg create --patterns-from patternfile.lst /path/to/repo::archive
+            borg create --exclude home/bobby/junk archive /home/bobby /home/susan
+            borg create --patterns-from patternfile.lst archive
 
         patternfile.lst::
 
@@ -3397,6 +3397,7 @@ class Archiver:
 
         It creates input data in memory, runs the operation and then displays throughput.
         To reduce outside influence on the timings, please make sure to run this with:
+
         - an otherwise as idle as possible machine
         - enough free memory so there will be no slow down due to paging activity
         """)
@@ -4127,21 +4128,21 @@ class Archiver:
         transfer_epilog = process_epilog("""
         This command transfers archives from one repository to another repository.
 
-        Suggested use:
+        Suggested use::
 
-        # initialize DST_REPO reusing key material from SRC_REPO, so that
-        # chunking and chunk id generation will work in the same way as before.
-        borg --repo=DST_REPO init --other-repo=SRC_REPO --encryption=DST_ENC
+            # initialize DST_REPO reusing key material from SRC_REPO, so that
+            # chunking and chunk id generation will work in the same way as before.
+            borg --repo=DST_REPO init --other-repo=SRC_REPO --encryption=DST_ENC
 
-        # transfer archives from SRC_REPO to DST_REPO
-        borg --repo=DST_REPO transfer --other-repo=SRC_REPO --dry-run  # check what it would do
-        borg --repo=DST_REPO transfer --other-repo=SRC_REPO            # do it!
-        borg --repo=DST_REPO transfer --other-repo=SRC_REPO --dry-run  # check! anything left?
+            # transfer archives from SRC_REPO to DST_REPO
+            borg --repo=DST_REPO transfer --other-repo=SRC_REPO --dry-run  # check what it would do
+            borg --repo=DST_REPO transfer --other-repo=SRC_REPO            # do it!
+            borg --repo=DST_REPO transfer --other-repo=SRC_REPO --dry-run  # check! anything left?
 
         The default is to transfer all archives, including checkpoint archives.
 
         You could use the misc. archive filter options to limit which archives it will
-        transfer, e.g. using the --prefix option. This is recommended for big
+        transfer, e.g. using the -a option. This is recommended for big
         repositories with multiple data sets to keep the runtime per invocation lower.
         """)
         subparser = subparsers.add_parser('transfer', parents=[common_parser], add_help=False,
@@ -4398,7 +4399,7 @@ class Archiver:
 
         ::
 
-            borg rcreate --encryption repokey /path/to/repo
+            borg rcreate --encryption repokey-aes-ocb
 
         Borg will:
 
@@ -4460,13 +4461,13 @@ class Archiver:
         +-----------------------------------+--------------+----------------+--------------------+---------+
         | Mode (K = keyfile or repokey)     | ID-Hash      | Encryption     | Authentication     | V >=    |
         +-----------------------------------+--------------+----------------+--------------------+---------+
-        | K-blake2-chacha20-poly1305        | BLAKE2b      | CHACHA20       | POLY1305           | 1.3     |
+        | K-blake2-chacha20-poly1305        | BLAKE2b      | CHACHA20       | POLY1305           | 2.0     |
         +-----------------------------------+--------------+----------------+--------------------+---------+
-        | K-chacha20-poly1305               | HMAC-SHA-256 | CHACHA20       | POLY1305           | 1.3     |
+        | K-chacha20-poly1305               | HMAC-SHA-256 | CHACHA20       | POLY1305           | 2.0     |
         +-----------------------------------+--------------+----------------+--------------------+---------+
-        | K-blake2-aes-ocb                  | BLAKE2b      | AES256-OCB     | AES256-OCB         | 1.3     |
+        | K-blake2-aes-ocb                  | BLAKE2b      | AES256-OCB     | AES256-OCB         | 2.0     |
         +-----------------------------------+--------------+----------------+--------------------+---------+
-        | K-aes-ocb                         | HMAC-SHA-256 | AES256-OCB     | AES256-OCB         | 1.3     |
+        | K-aes-ocb                         | HMAC-SHA-256 | AES256-OCB     | AES256-OCB         | 2.0     |
         +-----------------------------------+--------------+----------------+--------------------+---------+
         | K-blake2                          | BLAKE2b      | AES256-CTR     | BLAKE2b            | 1.1     |
         +-----------------------------------+--------------+----------------+--------------------+---------+
@@ -4495,8 +4496,6 @@ class Archiver:
           The key encryption key is derived from your passphrase via argon2-id.
           Argon2 is considered more modern and secure than pbkdf2.
 
-        - You can use ``--key-algorithm pbkdf2`` if you want to access your repo via old versions of borg.
-
         Our implementation of argon2-based key algorithm follows the cryptographic best practices:
 
         - It derives two separate keys from your passphrase: one to encrypt your key and another one
@@ -4635,11 +4634,13 @@ class Archiver:
         change_location_epilog = process_epilog("""
         Change the location of a borg key. The key can be stored at different locations:
 
-        keyfile: locally, usually in the home directory
-        repokey: inside the repo (in the repo config)
+        - keyfile: locally, usually in the home directory
+        - repokey: inside the repo (in the repo config)
 
-        Note: this command does NOT change the crypto algorithms, just the key location,
-              thus you must ONLY give the key location (keyfile or repokey).
+        Please note:
+
+        This command does NOT change the crypto algorithms, just the key location,
+        thus you must ONLY give the key location (keyfile or repokey).
         """)
         subparser = key_parsers.add_parser('change-location', parents=[common_parser], add_help=False,
                                           description=self.do_change_location.__doc__,
@@ -4752,13 +4753,18 @@ class Archiver:
         # borg rlist
         rlist_epilog = process_epilog("""
         This command lists the archives contained in a repository.
+
         .. man NOTES
+
         The FORMAT specifier syntax
         +++++++++++++++++++++++++++
+
         The ``--format`` option uses python's `format string syntax
         <https://docs.python.org/3.9/library/string.html#formatstrings>`_.
+
         Examples:
         ::
+
             $ borg rlist --format '{archive}{NL}'
             ArchiveFoo
             ArchiveBar
@@ -4774,6 +4780,7 @@ class Archiver:
         The following keys are always available:
 
         """) + BaseFormatter.keys_help() + textwrap.dedent("""
+
         Keys available only when listing archives in a repository:
 
         """) + ArchiveFormatter.keys_help()

From c36c75db59382ba122fbdb63751802de53cbdd27 Mon Sep 17 00:00:00 2001
From: Thomas Waldmann <tw@waldmann-edv.de>
Date: Sat, 25 Jun 2022 22:17:29 +0200
Subject: [PATCH 072/160] borg check: remove --name, better use -a

The glob can also match precisely one archive,
so this does the same with less code.
---
 src/borg/archive.py  | 38 ++++++++++++++------------------------
 src/borg/archiver.py |  8 +++-----
 2 files changed, 17 insertions(+), 29 deletions(-)

diff --git a/src/borg/archive.py b/src/borg/archive.py
index 016544da6..2c49c18fd 100644
--- a/src/borg/archive.py
+++ b/src/borg/archive.py
@@ -1534,19 +1534,18 @@ class ArchiveChecker:
         self.error_found = False
         self.possibly_superseded = set()
 
-    def check(self, repository, repair=False, archive=None, first=0, last=0, sort_by='', glob=None,
+    def check(self, repository, repair=False, first=0, last=0, sort_by='', glob=None,
               verify_data=False, save_space=False):
         """Perform a set of checks on 'repository'
 
         :param repair: enable repair mode, write updated or corrected data into repository
-        :param archive: only check this archive
         :param first/last/sort_by: only check this number of first/last archives ordered by sort_by
         :param glob: only check archives matching this glob
         :param verify_data: integrity verification of data referenced by archives
         :param save_space: Repository.commit(save_space)
         """
         logger.info('Starting archive consistency check...')
-        self.check_all = archive is None and not any((first, last, glob))
+        self.check_all = not any((first, last, glob))
         self.repair = repair
         self.repository = repository
         self.init_chunks()
@@ -1568,7 +1567,7 @@ class ArchiveChecker:
                 self.error_found = True
                 del self.chunks[Manifest.MANIFEST_ID]
                 self.manifest = self.rebuild_manifest()
-        self.rebuild_refcounts(archive=archive, first=first, last=last, sort_by=sort_by, glob=glob)
+        self.rebuild_refcounts(glob=glob, first=first, last=last, sort_by=sort_by)
         self.orphan_chunks_check()
         self.finish(save_space=save_space)
         if self.error_found:
@@ -1738,7 +1737,7 @@ class ArchiveChecker:
         logger.info('Manifest rebuild complete.')
         return manifest
 
-    def rebuild_refcounts(self, archive=None, first=0, last=0, sort_by='', glob=None):
+    def rebuild_refcounts(self, first=0, last=0, sort_by='', glob=None):
         """Rebuild object reference counts by walking the metadata
 
         Missing and/or incorrect data is repaired when detected
@@ -1909,26 +1908,17 @@ class ArchiveChecker:
                         raise
                     i += 1
 
-        if archive is None:
-            sort_by = sort_by.split(',')
-            if any((first, last, glob)):
-                archive_infos = self.manifest.archives.list(sort_by=sort_by, glob=glob, first=first, last=last)
-                if glob and not archive_infos:
-                    logger.warning('--glob-archives %s does not match any archives', glob)
-                if first and len(archive_infos) < first:
-                    logger.warning('--first %d archives: only found %d archives', first, len(archive_infos))
-                if last and len(archive_infos) < last:
-                    logger.warning('--last %d archives: only found %d archives', last, len(archive_infos))
-            else:
-                archive_infos = self.manifest.archives.list(sort_by=sort_by)
+        sort_by = sort_by.split(',')
+        if any((first, last, glob)):
+            archive_infos = self.manifest.archives.list(sort_by=sort_by, glob=glob, first=first, last=last)
+            if glob and not archive_infos:
+                logger.warning('--glob-archives %s does not match any archives', glob)
+            if first and len(archive_infos) < first:
+                logger.warning('--first %d archives: only found %d archives', first, len(archive_infos))
+            if last and len(archive_infos) < last:
+                logger.warning('--last %d archives: only found %d archives', last, len(archive_infos))
         else:
-            # we only want one specific archive
-            try:
-                archive_infos = [self.manifest.archives[archive]]
-            except KeyError:
-                logger.error("Archive '%s' not found.", archive)
-                self.error_found = True
-                return
+            archive_infos = self.manifest.archives.list(sort_by=sort_by)
         num_archives = len(archive_infos)
 
         pi = ProgressIndicatorPercent(total=num_archives, msg='Checking archives %3.1f%%', step=0.1,
diff --git a/src/borg/archiver.py b/src/borg/archiver.py
index 8218ca1cf..c734d4bdb 100644
--- a/src/borg/archiver.py
+++ b/src/borg/archiver.py
@@ -525,7 +525,8 @@ class Archiver:
                 return EXIT_ERROR
         if args.repo_only and any(
            (args.verify_data, args.first, args.last, args.prefix is not None, args.glob_archives)):
-            self.print_error("--repository-only contradicts --first, --last, --prefix and --verify-data arguments.")
+            self.print_error("--repository-only contradicts --first, --last, --prefix, --glob-archives "
+                             " and --verify-data arguments.")
             return EXIT_ERROR
         if args.repair and args.max_duration:
             self.print_error("--repair does not allow --max-duration argument.")
@@ -542,8 +543,7 @@ class Archiver:
                 return EXIT_WARNING
         if args.prefix is not None:
             args.glob_archives = args.prefix + '*'
-        if not args.repo_only and not ArchiveChecker().check(
-                repository, repair=args.repair, archive=args.name,
+        if not args.repo_only and not ArchiveChecker().check(repository, repair=args.repair,
                 first=args.first, last=args.last, sort_by=args.sort_by or 'ts', glob=args.glob_archives,
                 verify_data=args.verify_data, save_space=args.save_space):
             return EXIT_WARNING
@@ -3501,8 +3501,6 @@ class Archiver:
                                           formatter_class=argparse.RawDescriptionHelpFormatter,
                                           help='verify repository')
         subparser.set_defaults(func=self.do_check)
-        subparser.add_argument('--name', dest='name', metavar='NAME', type=NameSpec,
-                               help='specify the archive name')
         subparser.add_argument('--repository-only', dest='repo_only', action='store_true',
                                help='only perform repository checks')
         subparser.add_argument('--archives-only', dest='archives_only', action='store_true',

From 3fbb297fd746ffbce66e5d256ef828fe12f1f9a7 Mon Sep 17 00:00:00 2001
From: Thomas Waldmann <tw@waldmann-edv.de>
Date: Sun, 26 Jun 2022 00:07:07 +0200
Subject: [PATCH 073/160] compact: remove --cleanup-commits

this was a one-time fix only needed for borg 1.2.

users are expected to use borg 1.2 to cleanup the commits.
---
 src/borg/archiver.py   | 9 +--------
 src/borg/remote.py     | 5 ++---
 src/borg/repository.py | 9 +--------
 3 files changed, 4 insertions(+), 19 deletions(-)

diff --git a/src/borg/archiver.py b/src/borg/archiver.py
index d647e544f..c37b1ee27 100644
--- a/src/borg/archiver.py
+++ b/src/borg/archiver.py
@@ -2093,7 +2093,7 @@ class Archiver:
         data = repository.get(Manifest.MANIFEST_ID)
         repository.put(Manifest.MANIFEST_ID, data)
         threshold = args.threshold / 100
-        repository.commit(compact=True, threshold=threshold, cleanup_commits=args.cleanup_commits)
+        repository.commit(compact=True, threshold=threshold)
         return EXIT_SUCCESS
 
     @with_repository(exclusive=True, manifest=False)
@@ -3536,11 +3536,6 @@ class Archiver:
         given by the ``--threshold`` option. If omitted, a threshold of 10% is used.
         When using ``--verbose``, borg will output an estimate of the freed space.
 
-        After upgrading borg (server) to 1.2+, you can use ``borg compact --cleanup-commits``
-        to clean up the numerous 17byte commit-only segments that borg 1.1 did not clean up
-        due to a bug. It is enough to do that once per repository. After cleaning up the
-        commits, borg will also do a normal compaction.
-
         See :ref:`separate_compaction` in Additional Notes for more details.
         """)
         subparser = subparsers.add_parser('compact', parents=[common_parser], add_help=False,
@@ -3549,8 +3544,6 @@ class Archiver:
                                           formatter_class=argparse.RawDescriptionHelpFormatter,
                                           help='compact segment files / free space in repo')
         subparser.set_defaults(func=self.do_compact)
-        subparser.add_argument('--cleanup-commits', dest='cleanup_commits', action='store_true',
-                               help='cleanup commit-only 17-byte segment files')
         subparser.add_argument('--threshold', metavar='PERCENT', dest='threshold',
                                type=int, default=10,
                                help='set minimum threshold for saved space in PERCENT (Default: 10)')
diff --git a/src/borg/remote.py b/src/borg/remote.py
index 6ea51d3c3..ac7255aa7 100644
--- a/src/borg/remote.py
+++ b/src/borg/remote.py
@@ -905,9 +905,8 @@ This problem will go away as soon as the server has been upgraded to 1.0.7+.
 
     @api(since=parse_version('1.0.0'),
          compact={'since': parse_version('1.2.0a0'), 'previously': True, 'dontcare': True},
-         threshold={'since': parse_version('1.2.0a8'), 'previously': 0.1, 'dontcare': True},
-         cleanup_commits={'since': parse_version('1.2.0a0'), 'previously': False, 'dontcare': True})
-    def commit(self, save_space=False, compact=True, threshold=0.1, cleanup_commits=False):
+         threshold={'since': parse_version('1.2.0a8'), 'previously': 0.1, 'dontcare': True})
+    def commit(self, save_space=False, compact=True, threshold=0.1):
         """actual remoting is done via self.call in the @api decorator"""
 
     @api(since=parse_version('1.0.0'))
diff --git a/src/borg/repository.py b/src/borg/repository.py
index b2458dbf4..13f469fc5 100644
--- a/src/borg/repository.py
+++ b/src/borg/repository.py
@@ -495,7 +495,7 @@ class Repository:
             self.lock.release()
             self.lock = None
 
-    def commit(self, save_space=False, compact=True, threshold=0.1, cleanup_commits=False):
+    def commit(self, save_space=False, compact=True, threshold=0.1):
         """Commit transaction
         """
         # save_space is not used anymore, but stays for RPC/API compatibility.
@@ -509,13 +509,6 @@ class Repository:
         self.segments.setdefault(segment, 0)
         self.compact[segment] += LoggedIO.header_fmt.size
         if compact and not self.append_only:
-            if cleanup_commits:
-                # due to bug #2850, there might be a lot of commit-only segment files.
-                # this is for a one-time cleanup of these 17byte files.
-                for segment, filename in self.io.segment_iterator():
-                    if os.path.getsize(filename) == 17:
-                        self.segments[segment] = 0
-                        self.compact[segment] = LoggedIO.header_fmt.size
             self.compact_segments(threshold)
         self.write_index()
         self.rollback()

From dbae8e60eb62a90c9f294ab357b74ade22a5a862 Mon Sep 17 00:00:00 2001
From: Thomas Waldmann <tw@waldmann-edv.de>
Date: Sun, 26 Jun 2022 00:25:44 +0200
Subject: [PATCH 074/160] remove borg upgrade

---
 docs/usage.rst                 |   1 -
 docs/usage/upgrade.rst         |  16 -----
 docs/usage/upgrade.rst.inc     | 106 ---------------------------
 src/borg/archiver.py           | 128 ---------------------------------
 src/borg/crypto/key.py         |   7 +-
 src/borg/repository.py         |   2 +-
 src/borg/testsuite/archiver.py |  34 ---------
 7 files changed, 2 insertions(+), 292 deletions(-)
 delete mode 100644 docs/usage/upgrade.rst
 delete mode 100644 docs/usage/upgrade.rst.inc

diff --git a/docs/usage.rst b/docs/usage.rst
index 3e649b71d..9b9a72162 100644
--- a/docs/usage.rst
+++ b/docs/usage.rst
@@ -60,7 +60,6 @@ Usage
    usage/tar
 
    usage/transfer
-   usage/upgrade
    usage/benchmark
 
    usage/help
diff --git a/docs/usage/upgrade.rst b/docs/usage/upgrade.rst
deleted file mode 100644
index 8ebd96e4c..000000000
--- a/docs/usage/upgrade.rst
+++ /dev/null
@@ -1,16 +0,0 @@
-.. include:: upgrade.rst.inc
-
-Examples
-~~~~~~~~
-::
-
-    # Upgrade the borg repository to the most recent version.
-    $ borg upgrade -v /path/to/repo
-    making a hardlink copy in /path/to/repo.before-upgrade-2016-02-15-20:51:55
-    opening attic repository with borg and converting
-    no key file found for repository
-    converting repo index /path/to/repo/index.0
-    converting 1 segments...
-    converting borg 0.xx to borg current
-    no key file found for repository
-
diff --git a/docs/usage/upgrade.rst.inc b/docs/usage/upgrade.rst.inc
deleted file mode 100644
index f1cd806ef..000000000
--- a/docs/usage/upgrade.rst.inc
+++ /dev/null
@@ -1,106 +0,0 @@
-.. IMPORTANT: this file is auto-generated from borg's built-in help, do not edit!
-
-.. _borg_upgrade:
-
-borg upgrade
-------------
-.. code-block:: none
-
-    borg [common options] upgrade [options]
-
-.. only:: html
-
-    .. class:: borg-options-table
-
-    +-------------------------------------------------------+-----------------------+------------------------------------------------------------------------------------------------+
-    | **optional arguments**                                                                                                                                                         |
-    +-------------------------------------------------------+-----------------------+------------------------------------------------------------------------------------------------+
-    |                                                       | ``-n``, ``--dry-run`` | do not change repository                                                                       |
-    +-------------------------------------------------------+-----------------------+------------------------------------------------------------------------------------------------+
-    |                                                       | ``--inplace``         | rewrite repository in place, with no chance of going back to older versions of the repository. |
-    +-------------------------------------------------------+-----------------------+------------------------------------------------------------------------------------------------+
-    |                                                       | ``--force``           | Force upgrade                                                                                  |
-    +-------------------------------------------------------+-----------------------+------------------------------------------------------------------------------------------------+
-    |                                                       | ``--tam``             | Enable manifest authentication (in key and cache) (Borg 1.0.9 and later).                      |
-    +-------------------------------------------------------+-----------------------+------------------------------------------------------------------------------------------------+
-    |                                                       | ``--disable-tam``     | Disable manifest authentication (in key and cache).                                            |
-    +-------------------------------------------------------+-----------------------+------------------------------------------------------------------------------------------------+
-    | .. class:: borg-common-opt-ref                                                                                                                                                 |
-    |                                                                                                                                                                                |
-    | :ref:`common_options`                                                                                                                                                          |
-    +-------------------------------------------------------+-----------------------+------------------------------------------------------------------------------------------------+
-
-    .. raw:: html
-
-        <script type='text/javascript'>
-        $(document).ready(function () {
-            $('.borg-options-table colgroup').remove();
-        })
-        </script>
-
-.. only:: latex
-
-
-
-    optional arguments
-        -n, --dry-run     do not change repository
-        --inplace         rewrite repository in place, with no chance of going back to older versions of the repository.
-        --force           Force upgrade
-        --tam             Enable manifest authentication (in key and cache) (Borg 1.0.9 and later).
-        --disable-tam     Disable manifest authentication (in key and cache).
-
-
-    :ref:`common_options`
-        |
-
-Description
-~~~~~~~~~~~
-
-Upgrade an existing, local Borg repository.
-
-When you do not need borg upgrade
-+++++++++++++++++++++++++++++++++
-
-Not every change requires that you run ``borg upgrade``.
-
-You do **not** need to run it when:
-
-- moving your repository to a different place
-- upgrading to another point release (like 1.0.x to 1.0.y),
-  except when noted otherwise in the changelog
-- upgrading from 1.0.x to 1.1.x,
-  except when noted otherwise in the changelog
-
-Borg 1.x.y upgrades
-+++++++++++++++++++
-
-Use ``borg upgrade --tam REPO`` to require manifest authentication
-introduced with Borg 1.0.9 to address security issues. This means
-that modifying the repository after doing this with a version prior
-to 1.0.9 will raise a validation error, so only perform this upgrade
-after updating all clients using the repository to 1.0.9 or newer.
-
-This upgrade should be done on each client for safety reasons.
-
-If a repository is accidentally modified with a pre-1.0.9 client after
-this upgrade, use ``borg upgrade --tam --force REPO`` to remedy it.
-
-If you routinely do this you might not want to enable this upgrade
-(which will leave you exposed to the security issue). You can
-reverse the upgrade by issuing ``borg upgrade --disable-tam REPO``.
-
-See
-https://borgbackup.readthedocs.io/en/stable/changes.html#pre-1-0-9-manifest-spoofing-vulnerability
-for details.
-
-Borg 0.xx to Borg 1.x
-+++++++++++++++++++++
-
-This currently supports converting Borg 0.xx to 1.0.
-
-Currently, only LOCAL repositories can be upgraded (issue #465).
-
-Please note that ``borg create`` (since 1.0.0) uses bigger chunks by
-default than old borg did, so the new chunks won't deduplicate
-with the old chunks in the upgraded repository.
-See ``--chunker-params`` option of ``borg create`` and ``borg recreate``.
\ No newline at end of file
diff --git a/src/borg/archiver.py b/src/borg/archiver.py
index c37b1ee27..0cfbe3adf 100644
--- a/src/borg/archiver.py
+++ b/src/borg/archiver.py
@@ -490,16 +490,6 @@ class Archiver:
         if key.tam_required:
             tam_file = tam_required_file(repository)
             open(tam_file, 'w').close()
-            logger.warning(
-                '\n'
-                'By default repositories initialized with this version will produce security\n'
-                'errors if written to with an older version (up to and including Borg 1.0.8).\n'
-                '\n'
-                'If you want to use these older versions, you can disable the check by running:\n'
-                'borg upgrade --disable-tam %s\n'
-                '\n'
-                'See https://borgbackup.readthedocs.io/en/stable/changes.html#pre-1-0-9-manifest-spoofing-vulnerability '
-                'for details about the security implications.', shlex.quote(path))
 
         if key.NAME != 'plaintext':
             logger.warning(
@@ -1892,56 +1882,6 @@ class Archiver:
                           logger=logging.getLogger('borg.output.stats'))
         return self.exit_code
 
-    @with_repository(fake=('tam', 'disable_tam'), invert_fake=True, manifest=False, exclusive=True)
-    def do_upgrade(self, args, repository, manifest=None, key=None):
-        """upgrade a repository from a previous version"""
-        if args.tam:
-            manifest, key = Manifest.load(repository, (Manifest.Operation.CHECK,), force_tam_not_required=args.force)
-
-            if not hasattr(key, 'change_passphrase'):
-                print('This repository is not encrypted, cannot enable TAM.')
-                return EXIT_ERROR
-
-            if not manifest.tam_verified or not manifest.config.get('tam_required', False):
-                # The standard archive listing doesn't include the archive ID like in borg 1.1.x
-                print('Manifest contents:')
-                for archive_info in manifest.archives.list(sort_by=['ts']):
-                    print(format_archive(archive_info), '[%s]' % bin_to_hex(archive_info.id))
-                manifest.config['tam_required'] = True
-                manifest.write()
-                repository.commit(compact=False)
-            if not key.tam_required:
-                key.tam_required = True
-                key.change_passphrase(key._passphrase)
-                print('Key updated')
-                if hasattr(key, 'find_key'):
-                    print('Key location:', key.find_key())
-            if not tam_required(repository):
-                tam_file = tam_required_file(repository)
-                open(tam_file, 'w').close()
-                print('Updated security database')
-        elif args.disable_tam:
-            manifest, key = Manifest.load(repository, Manifest.NO_OPERATION_CHECK, force_tam_not_required=True)
-            if tam_required(repository):
-                os.unlink(tam_required_file(repository))
-            if key.tam_required:
-                key.tam_required = False
-                key.change_passphrase(key._passphrase)
-                print('Key updated')
-                if hasattr(key, 'find_key'):
-                    print('Key location:', key.find_key())
-            manifest.config['tam_required'] = False
-            manifest.write()
-            repository.commit(compact=False)
-        else:
-            # mainly for upgrades from borg 0.xx -> 1.0.
-            repo = BorgRepositoryUpgrader(args.location.path, create=False)
-            try:
-                repo.upgrade(args.dry_run, inplace=args.inplace, progress=args.progress)
-            except NotImplementedError as e:
-                print("warning: %s" % e)
-        return self.exit_code
-
     @with_repository(cache=True, exclusive=True, compatibility=(Manifest.Operation.CHECK,))
     def do_recreate(self, args, repository, manifest, key, cache):
         """Re-create archives"""
@@ -5070,74 +5010,6 @@ class Archiver:
         subparser.add_argument('mountpoint', metavar='MOUNTPOINT', type=str,
                                help='mountpoint of the filesystem to umount')
 
-        # borg upgrade
-        upgrade_epilog = process_epilog("""
-        Upgrade an existing, local Borg repository.
-
-        When you do not need borg upgrade
-        +++++++++++++++++++++++++++++++++
-
-        Not every change requires that you run ``borg upgrade``.
-
-        You do **not** need to run it when:
-
-        - moving your repository to a different place
-        - upgrading to another point release (like 1.0.x to 1.0.y),
-          except when noted otherwise in the changelog
-        - upgrading from 1.0.x to 1.1.x,
-          except when noted otherwise in the changelog
-
-        Borg 1.x.y upgrades
-        +++++++++++++++++++
-
-        Use ``borg upgrade --tam REPO`` to require manifest authentication
-        introduced with Borg 1.0.9 to address security issues. This means
-        that modifying the repository after doing this with a version prior
-        to 1.0.9 will raise a validation error, so only perform this upgrade
-        after updating all clients using the repository to 1.0.9 or newer.
-
-        This upgrade should be done on each client for safety reasons.
-
-        If a repository is accidentally modified with a pre-1.0.9 client after
-        this upgrade, use ``borg upgrade --tam --force REPO`` to remedy it.
-
-        If you routinely do this you might not want to enable this upgrade
-        (which will leave you exposed to the security issue). You can
-        reverse the upgrade by issuing ``borg upgrade --disable-tam REPO``.
-
-        See
-        https://borgbackup.readthedocs.io/en/stable/changes.html#pre-1-0-9-manifest-spoofing-vulnerability
-        for details.
-
-        Borg 0.xx to Borg 1.x
-        +++++++++++++++++++++
-
-        This currently supports converting Borg 0.xx to 1.0.
-
-        Currently, only LOCAL repositories can be upgraded (issue #465).
-
-        Please note that ``borg create`` (since 1.0.0) uses bigger chunks by
-        default than old borg did, so the new chunks won't deduplicate
-        with the old chunks in the upgraded repository.
-        See ``--chunker-params`` option of ``borg create`` and ``borg recreate``.""")
-        subparser = subparsers.add_parser('upgrade', parents=[common_parser], add_help=False,
-                                          description=self.do_upgrade.__doc__,
-                                          epilog=upgrade_epilog,
-                                          formatter_class=argparse.RawDescriptionHelpFormatter,
-                                          help='upgrade repository format')
-        subparser.set_defaults(func=self.do_upgrade)
-        subparser.add_argument('-n', '--dry-run', dest='dry_run', action='store_true',
-                               help='do not change repository')
-        subparser.add_argument('--inplace', dest='inplace', action='store_true',
-                               help='rewrite repository in place, with no chance of going back '
-                                    'to older versions of the repository.')
-        subparser.add_argument('--force', dest='force', action='store_true',
-                               help='Force upgrade')
-        subparser.add_argument('--tam', dest='tam', action='store_true',
-                               help='Enable manifest authentication (in key and cache) (Borg 1.0.9 and later).')
-        subparser.add_argument('--disable-tam', dest='disable_tam', action='store_true',
-                               help='Disable manifest authentication (in key and cache).')
-
         # borg with-lock
         with_lock_epilog = process_epilog("""
         This command runs a user-specified command while the repository lock is held.
diff --git a/src/borg/crypto/key.py b/src/borg/crypto/key.py
index 2b7b50da8..7dfda5851 100644
--- a/src/borg/crypto/key.py
+++ b/src/borg/crypto/key.py
@@ -61,12 +61,7 @@ class UnsupportedKeyFormatError(Error):
 
 class TAMRequiredError(IntegrityError):
     __doc__ = textwrap.dedent("""
-    Manifest is unauthenticated, but it is required for this repository.
-
-    This either means that you are under attack, or that you modified this repository
-    with a Borg version older than 1.0.9 after TAM authentication was enabled.
-
-    In the latter case, use "borg upgrade --tam --force '{}'" to re-authenticate the manifest.
+    Manifest is unauthenticated, but it is required for this repository. Is somebody attacking you?
     """).strip()
     traceback = False
 
diff --git a/src/borg/repository.py b/src/borg/repository.py
index 13f469fc5..420dea516 100644
--- a/src/borg/repository.py
+++ b/src/borg/repository.py
@@ -153,7 +153,7 @@ class Repository:
         """{} does not have a valid configuration. Check repo config [{}]."""
 
     class AtticRepository(Error):
-        """Attic repository detected. Please use borg < 1.3 to run "borg upgrade {}"."""
+        """Attic repository detected. Please use borg <= 1.2 to run "borg upgrade {}"."""
 
     class CheckNeeded(ErrorWithTraceback):
         """Inconsistency detected. Please run "borg check {}"."""
diff --git a/src/borg/testsuite/archiver.py b/src/borg/testsuite/archiver.py
index a3907c2c9..54c4fdaa4 100644
--- a/src/borg/testsuite/archiver.py
+++ b/src/borg/testsuite/archiver.py
@@ -3888,21 +3888,6 @@ class ManifestAuthenticationTest(ArchiverTestCaseBase):
         self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
         self.create_src_archive('archive1234')
         repository = Repository(self.repository_path, exclusive=True)
-        with repository:
-            shutil.rmtree(get_security_dir(bin_to_hex(repository.id)))
-            _, key = Manifest.load(repository, Manifest.NO_OPERATION_CHECK)
-            key.tam_required = False
-            key.change_passphrase(key._passphrase)
-
-            manifest = msgpack.unpackb(key.decrypt(Manifest.MANIFEST_ID, repository.get(Manifest.MANIFEST_ID)))
-            del manifest['tam']
-            repository.put(Manifest.MANIFEST_ID, key.encrypt(Manifest.MANIFEST_ID, msgpack.packb(manifest)))
-            repository.commit(compact=False)
-        output = self.cmd(f'--repo={self.repository_location}', 'rlist', '--debug')
-        assert 'archive1234' in output
-        assert 'TAM not found and not required' in output
-        # Run upgrade
-        self.cmd(f'--repo={self.repository_location}', 'upgrade', '--tam')
         # Manifest must be authenticated now
         output = self.cmd(f'--repo={self.repository_location}', 'rlist', '--debug')
         assert 'archive1234' in output
@@ -3912,25 +3897,6 @@ class ManifestAuthenticationTest(ArchiverTestCaseBase):
         # Fails
         with pytest.raises(TAMRequiredError):
             self.cmd(f'--repo={self.repository_location}', 'rlist')
-        # Force upgrade
-        self.cmd(f'--repo={self.repository_location}', 'upgrade', '--tam', '--force')
-        self.cmd(f'--repo={self.repository_location}', 'rlist')
-
-    def test_disable(self):
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
-        self.create_src_archive('archive1234')
-        self.cmd(f'--repo={self.repository_location}', 'upgrade', '--disable-tam')
-        repository = Repository(self.repository_path, exclusive=True)
-        self.spoof_manifest(repository)
-        assert not self.cmd(f'--repo={self.repository_location}', 'rlist')
-
-    def test_disable2(self):
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
-        self.create_src_archive('archive1234')
-        repository = Repository(self.repository_path, exclusive=True)
-        self.spoof_manifest(repository)
-        self.cmd(f'--repo={self.repository_location}', 'upgrade', '--disable-tam')
-        assert not self.cmd(f'--repo={self.repository_location}', 'rlist')
 
 
 class RemoteArchiverTestCase(ArchiverTestCase):

From d15791e45f392def195a3dea1f7355762153e9b8 Mon Sep 17 00:00:00 2001
From: Thomas Waldmann <tw@waldmann-edv.de>
Date: Sun, 26 Jun 2022 00:30:13 +0200
Subject: [PATCH 075/160] authors: remove 3rd party lib authors

we do not include the source code of these libs any more.
---
 AUTHORS | 24 ------------------------
 1 file changed, 24 deletions(-)

diff --git a/AUTHORS b/AUTHORS
index aebc8a1dd..5378b3b6c 100644
--- a/AUTHORS
+++ b/AUTHORS
@@ -44,27 +44,3 @@ Attic Patches and Suggestions
 - Johann Klähn
 - Petros Moisiadis
 - Thomas Waldmann
-
-BLAKE2
-------
-
-Borg includes BLAKE2: Copyright 2012, Samuel Neves <sneves@dei.uc.pt>, licensed under the terms
-of the CC0, the OpenSSL Licence, or the Apache Public License 2.0.
-
-Slicing CRC32
--------------
-
-Borg includes a fast slice-by-8 implementation of CRC32, Copyright 2011-2015 Stephan Brumme,
-licensed under the terms of a zlib license. See http://create.stephan-brumme.com/crc32/
-
-Folding CRC32
--------------
-
-Borg includes an extremely fast folding implementation of CRC32, Copyright 2013 Intel Corporation,
-licensed under the terms of the zlib license.
-
-xxHash
-------
-
-XXH64, a fast non-cryptographic hash algorithm. Copyright 2012-2016 Yann Collet,
-licensed under a BSD 2-clause license.

From 391178e68ef2a20816b14257d8916af1e8b7aba1 Mon Sep 17 00:00:00 2001
From: Thomas Waldmann <tw@waldmann-edv.de>
Date: Sun, 26 Jun 2022 01:03:58 +0200
Subject: [PATCH 076/160] update CHANGES

---
 docs/changes.rst | 22 ++++++++++++++++------
 1 file changed, 16 insertions(+), 6 deletions(-)

diff --git a/docs/changes.rst b/docs/changes.rst
index e6ac6bc1d..17c896a94 100644
--- a/docs/changes.rst
+++ b/docs/changes.rst
@@ -61,12 +61,12 @@ Compatibility notes:
 
       - borg create ARCHIVE ...
       - borg list ARCHIVE
+      - borg extract ARCHIVE ...
+      - borg diff ARCH1 ARCH2
+      - borg rename OLDNAME NEWNAME
       - borg info -a ARCH_GLOB
       - borg delete -a ARCH_GLOB
-      - borg diff ARCH1 ARCH2
-      - borg extract ARCHIVE ...
       - borg recreate -a ARCH_GLOB ...
-      - borg rename OLDNAME NEWNAME
       - borg mount -a ARCH_GLOB mountpoint ...
 
     For more details, please consult the docs or --help option output.
@@ -95,11 +95,15 @@ Changes:
   - symmetric hlid (all hardlinks pointing to same inode have same hlid)
   - all archived hardlinked regular files have a chunks list
 
-- borg init --other-repo=OTHER_REPO: reuse key material from OTHER_REPO, #6554
+- borg init --other-repo=OTHER_REPO: reuse key material from OTHER_REPO, #6554.
+  This is useful if you want to use borg transfer to transfer archives from an
+  existing borg 1.1/1.2 repo. If the chunker secret and the id key and algorithm
+  stay the same, the deduplication will also work between past and future backups.
+
 - borg transfer:
 
-  - efficiently copy archives from borg 1.1/1.2 repo to new repo. uses
-    deduplication and does not decompress/recompress file content data.
+  - efficiently copy archives from a borg 1.1/1.2 repo to a new repo.
+    uses deduplication and does not decompress/recompress file content data.
   - does some cleanups / fixes / conversions:
 
     - disallow None value for .user/group/chunks/chunks_healthy
@@ -111,9 +115,15 @@ Changes:
     - all hardlinks have chunks, maybe chunks_healty, hlid
     - remove the zlib type bytes hack
     - make sure items with chunks have precomputed size
+    - removes the csize element from the tuples in the Item.chunks list
     - clean item of attic 0.13 'acl' bug remnants
 
 - crypto: see 1.3.0a1 log entry
+- removed "borg upgrade" command (not needed any more)
+- compact: removed --cleanup-commits option
+- docs: fixed quickstart and usage docs with new cli command syntax
+- docs: removed the parts talking about AES-CTR mode issues (we will not
+  use that any more)
 
 
 Version 1.3.0a1 (2022-04-15)

From 3232cb4a7ea5d35753c81f503ccdf84d60b36dc7 Mon Sep 17 00:00:00 2001
From: Thomas Waldmann <tw@waldmann-edv.de>
Date: Sun, 26 Jun 2022 01:22:28 +0200
Subject: [PATCH 077/160] transfer: add a specific transfer example

---
 docs/usage/transfer.rst | 29 +++++++++++++++++++++++++++++
 1 file changed, 29 insertions(+)

diff --git a/docs/usage/transfer.rst b/docs/usage/transfer.rst
index 4d9f1998a..45af40bee 100644
--- a/docs/usage/transfer.rst
+++ b/docs/usage/transfer.rst
@@ -1 +1,30 @@
 .. include:: transfer.rst.inc
+
+Examples
+~~~~~~~~
+::
+    # 0. Have borg 2.0 installed on client AND server, have a b12 repo copy for testing.
+
+    # 1. Create a new "related" repository:
+    # here, the existing borg 1.2 repo used repokey-blake2 (and aes-ctr mode),
+    # thus we use repokey-blake2-aes-ocb for the new borg 2.0 repo.
+    # staying with the same chunk id algorithm (blake2) and with the same
+    # key material (via --other-repo <oldrepo>) will make deduplication work
+    # between old archives (copied with borg transfer) and future ones.
+    # the AEAD cipher does not matter (everything must be re-encrypted and
+    # re-authenticated anyway), you could also choose repokey-blake2-chacha20-poly1305.
+    # in case your old borg repo did not use blake2, just remove the "-blake2".
+    $ borg --repo       ssh://borg2@borgbackup/./tests/b20 rcreate \
+           --other-repo ssh://borg2@borgbackup/./tests/b12 -e repokey-blake2-aes-ocb
+
+    # 2. Check what and how much it would transfer:
+    $ borg --repo       ssh://borg2@borgbackup/./tests/b20 transfer \
+           --other-repo ssh://borg2@borgbackup/./tests/b12 --dry-run
+
+    # 3. Transfer (copy) archives from old repo into new repo (takes time and space!):
+    $ borg --repo       ssh://borg2@borgbackup/./tests/b20 transfer \
+           --other-repo ssh://borg2@borgbackup/./tests/b12
+
+    # 4. Check if we have everything (same as 2.):
+    $ borg --repo       ssh://borg2@borgbackup/./tests/b20 transfer \
+           --other-repo ssh://borg2@borgbackup/./tests/b12 --dry-run

From 20bf97a8a4294b434cf7dcf7fd304a1c85135154 Mon Sep 17 00:00:00 2001
From: Thomas Waldmann <tw@waldmann-edv.de>
Date: Sun, 26 Jun 2022 13:52:47 +0200
Subject: [PATCH 078/160] CHANGES: set release date, formatting

---
 docs/changes.rst | 19 ++++++-------------
 1 file changed, 6 insertions(+), 13 deletions(-)

diff --git a/docs/changes.rst b/docs/changes.rst
index 17c896a94..669ef3c0e 100644
--- a/docs/changes.rst
+++ b/docs/changes.rst
@@ -12,8 +12,8 @@ This section provides information about security and corruption issues.
 Change Log 2.x
 ==============
 
-Version 2.0.0a2 (not released yet)
-----------------------------------
+Version 2.0.0a2 (2022-06-26)
+----------------------------
 
 Please note:
 
@@ -35,7 +35,8 @@ Compatibility notes:
 - command line syntax was changed, scripts and wrappers will need changes:
 
   - you will usually either export BORG_REPO=<MYREPO> into your environment or
-    call borg like: borg -r <MYREPO> command (-r ... usually omitted for brevity)
+    call borg like: "borg -r <MYREPO> <COMMAND>".
+    in the docs, we usually omit "-r ..." for brevity.
   - the scp-style REPO syntax was removed, please use ssh://..., #6697
   - differently than with borg 1.x you ONLY give the repo there, never a ::archive.
   - the archive name is either given as a positional parameter, like:
@@ -56,7 +57,6 @@ Compatibility notes:
       - borg rlist  # "repo list"
       - borg rinfo  # "repo info"
       - borg rdelete  # "repo delete"
-
     - borg 2 archive commands:
 
       - borg create ARCHIVE ...
@@ -78,28 +78,22 @@ Changes:
   - use -r or --repo or BORG_REPO env var to give the repository
   - use --other-repo or BORG_OTHER_REPO to give another repo (e.g. borg transfer)
   - use positional argument for archive name or `-a ARCH_GLOB`
-
 - remove support for scp-style repo specification, use ssh://...
 - simplify stats output: repo ops -> repo stats, archive ops -> archive stats
-
 - repository index: add payload size (==csize) and flags to NSIndex entries
 - repository index: set/query flags, iteration over flagged items (NSIndex)
 - repository: sync write file in get_fd
-
 - stats: deduplicated size now, was deduplicated compressed size in borg 1.x
 - remove csize support at most places in the code (chunks index, stats, get_size,
   Item.chunks)
-
 - replace problematic/ugly hardlink_master approach of borg 1.x by:
 
   - symmetric hlid (all hardlinks pointing to same inode have same hlid)
   - all archived hardlinked regular files have a chunks list
-
 - borg init --other-repo=OTHER_REPO: reuse key material from OTHER_REPO, #6554.
   This is useful if you want to use borg transfer to transfer archives from an
   existing borg 1.1/1.2 repo. If the chunker secret and the id key and algorithm
   stay the same, the deduplication will also work between past and future backups.
-
 - borg transfer:
 
   - efficiently copy archives from a borg 1.1/1.2 repo to a new repo.
@@ -117,13 +111,12 @@ Changes:
     - make sure items with chunks have precomputed size
     - removes the csize element from the tuples in the Item.chunks list
     - clean item of attic 0.13 'acl' bug remnants
-
 - crypto: see 1.3.0a1 log entry
 - removed "borg upgrade" command (not needed any more)
 - compact: removed --cleanup-commits option
 - docs: fixed quickstart and usage docs with new cli command syntax
-- docs: removed the parts talking about AES-CTR mode issues (we will not
-  use that any more)
+- docs: removed the parts talking about potential AES-CTR mode issues
+  (we will not use that any more).
 
 
 Version 1.3.0a1 (2022-04-15)

From ab25bf8175ab70e589b9a9cee5aff9f14a1e8104 Mon Sep 17 00:00:00 2001
From: Thomas Waldmann <tw@waldmann-edv.de>
Date: Sun, 26 Jun 2022 13:56:33 +0200
Subject: [PATCH 079/160] build_usage build_man

---
 docs/man/borg-benchmark-cpu.1         |  2 +-
 docs/man/borg-benchmark-crud.1        |  2 +-
 docs/man/borg-benchmark.1             |  2 +-
 docs/man/borg-break-lock.1            |  2 +-
 docs/man/borg-check.1                 |  5 +--
 docs/man/borg-common.1                |  2 +-
 docs/man/borg-compact.1               | 10 +----
 docs/man/borg-compression.1           |  2 +-
 docs/man/borg-config.1                |  2 +-
 docs/man/borg-create.1                |  2 +-
 docs/man/borg-delete.1                |  2 +-
 docs/man/borg-diff.1                  |  2 +-
 docs/man/borg-export-tar.1            |  2 +-
 docs/man/borg-extract.1               |  2 +-
 docs/man/borg-import-tar.1            |  2 +-
 docs/man/borg-info.1                  |  2 +-
 docs/man/borg-key-change-algorithm.1  |  2 +-
 docs/man/borg-key-change-location.1   |  2 +-
 docs/man/borg-key-change-passphrase.1 |  2 +-
 docs/man/borg-key-export.1            |  2 +-
 docs/man/borg-key-import.1            |  2 +-
 docs/man/borg-key.1                   |  2 +-
 docs/man/borg-list.1                  |  2 +-
 docs/man/borg-mount.1                 |  2 +-
 docs/man/borg-patterns.1              |  2 +-
 docs/man/borg-placeholders.1          |  2 +-
 docs/man/borg-prune.1                 |  2 +-
 docs/man/borg-rcreate.1               |  2 +-
 docs/man/borg-rdelete.1               |  2 +-
 docs/man/borg-recreate.1              |  2 +-
 docs/man/borg-rename.1                |  2 +-
 docs/man/borg-rinfo.1                 |  2 +-
 docs/man/borg-rlist.1                 |  2 +-
 docs/man/borg-serve.1                 |  2 +-
 docs/man/borg-transfer.1              | 56 ++++++++++++++++++++++++++-
 docs/man/borg-umount.1                |  2 +-
 docs/man/borg-with-lock.1             |  2 +-
 docs/man/borg.1                       |  2 +-
 docs/man/borgfs.1                     |  2 +-
 docs/usage/check.rst.inc              |  3 --
 docs/usage/compact.rst.inc            |  8 ----
 41 files changed, 93 insertions(+), 61 deletions(-)

diff --git a/docs/man/borg-benchmark-cpu.1 b/docs/man/borg-benchmark-cpu.1
index 9c3f4e0d4..ebafe2611 100644
--- a/docs/man/borg-benchmark-cpu.1
+++ b/docs/man/borg-benchmark-cpu.1
@@ -27,7 +27,7 @@ level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .in \\n[rst2man-indent\\n[rst2man-indent-level]]u
 ..
-.TH "BORG-BENCHMARK-CPU" 1 "2022-06-25" "" "borg backup tool"
+.TH "BORG-BENCHMARK-CPU" 1 "2022-06-26" "" "borg backup tool"
 .SH NAME
 borg-benchmark-cpu \- Benchmark CPU bound operations.
 .SH SYNOPSIS
diff --git a/docs/man/borg-benchmark-crud.1 b/docs/man/borg-benchmark-crud.1
index 89cd546ec..0dc00b27a 100644
--- a/docs/man/borg-benchmark-crud.1
+++ b/docs/man/borg-benchmark-crud.1
@@ -27,7 +27,7 @@ level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .in \\n[rst2man-indent\\n[rst2man-indent-level]]u
 ..
-.TH "BORG-BENCHMARK-CRUD" 1 "2022-06-25" "" "borg backup tool"
+.TH "BORG-BENCHMARK-CRUD" 1 "2022-06-26" "" "borg backup tool"
 .SH NAME
 borg-benchmark-crud \- Benchmark Create, Read, Update, Delete for archives.
 .SH SYNOPSIS
diff --git a/docs/man/borg-benchmark.1 b/docs/man/borg-benchmark.1
index c832a7925..405c96248 100644
--- a/docs/man/borg-benchmark.1
+++ b/docs/man/borg-benchmark.1
@@ -27,7 +27,7 @@ level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .in \\n[rst2man-indent\\n[rst2man-indent-level]]u
 ..
-.TH "BORG-BENCHMARK" 1 "2022-06-25" "" "borg backup tool"
+.TH "BORG-BENCHMARK" 1 "2022-06-26" "" "borg backup tool"
 .SH NAME
 borg-benchmark \- benchmark command
 .SH SYNOPSIS
diff --git a/docs/man/borg-break-lock.1 b/docs/man/borg-break-lock.1
index 81c290601..2332c86ad 100644
--- a/docs/man/borg-break-lock.1
+++ b/docs/man/borg-break-lock.1
@@ -27,7 +27,7 @@ level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .in \\n[rst2man-indent\\n[rst2man-indent-level]]u
 ..
-.TH "BORG-BREAK-LOCK" 1 "2022-06-25" "" "borg backup tool"
+.TH "BORG-BREAK-LOCK" 1 "2022-06-26" "" "borg backup tool"
 .SH NAME
 borg-break-lock \- Break the repository lock (e.g. in case it was left by a dead borg.
 .SH SYNOPSIS
diff --git a/docs/man/borg-check.1 b/docs/man/borg-check.1
index 9ec8e69f9..6f2835d2d 100644
--- a/docs/man/borg-check.1
+++ b/docs/man/borg-check.1
@@ -27,7 +27,7 @@ level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .in \\n[rst2man-indent\\n[rst2man-indent-level]]u
 ..
-.TH "BORG-CHECK" 1 "2022-06-25" "" "borg backup tool"
+.TH "BORG-CHECK" 1 "2022-06-26" "" "borg backup tool"
 .SH NAME
 borg-check \- Check repository consistency
 .SH SYNOPSIS
@@ -129,9 +129,6 @@ See \fIborg\-common(1)\fP for common options of Borg commands.
 .SS optional arguments
 .INDENT 0.0
 .TP
-.BI \-\-name \ NAME
-specify the archive name
-.TP
 .B  \-\-repository\-only
 only perform repository checks
 .TP
diff --git a/docs/man/borg-common.1 b/docs/man/borg-common.1
index 5e960b713..c702af4fe 100644
--- a/docs/man/borg-common.1
+++ b/docs/man/borg-common.1
@@ -27,7 +27,7 @@ level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .in \\n[rst2man-indent\\n[rst2man-indent-level]]u
 ..
-.TH "BORG-COMMON" 1 "2022-06-25" "" "borg backup tool"
+.TH "BORG-COMMON" 1 "2022-06-26" "" "borg backup tool"
 .SH NAME
 borg-common \- Common options of Borg commands
 .SH SYNOPSIS
diff --git a/docs/man/borg-compact.1 b/docs/man/borg-compact.1
index 18d79ee76..03e64ba14 100644
--- a/docs/man/borg-compact.1
+++ b/docs/man/borg-compact.1
@@ -27,7 +27,7 @@ level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .in \\n[rst2man-indent\\n[rst2man-indent-level]]u
 ..
-.TH "BORG-COMPACT" 1 "2022-06-25" "" "borg backup tool"
+.TH "BORG-COMPACT" 1 "2022-06-26" "" "borg backup tool"
 .SH NAME
 borg-compact \- compact segment files in the repository
 .SH SYNOPSIS
@@ -51,11 +51,6 @@ A segment is compacted if the amount of saved space is above the percentage valu
 given by the \fB\-\-threshold\fP option. If omitted, a threshold of 10% is used.
 When using \fB\-\-verbose\fP, borg will output an estimate of the freed space.
 .sp
-After upgrading borg (server) to 1.2+, you can use \fBborg compact \-\-cleanup\-commits\fP
-to clean up the numerous 17byte commit\-only segments that borg 1.1 did not clean up
-due to a bug. It is enough to do that once per repository. After cleaning up the
-commits, borg will also do a normal compaction.
-.sp
 See \fIseparate_compaction\fP in Additional Notes for more details.
 .SH OPTIONS
 .sp
@@ -63,9 +58,6 @@ See \fIborg\-common(1)\fP for common options of Borg commands.
 .SS optional arguments
 .INDENT 0.0
 .TP
-.B  \-\-cleanup\-commits
-cleanup commit\-only 17\-byte segment files
-.TP
 .BI \-\-threshold \ PERCENT
 set minimum threshold for saved space in PERCENT (Default: 10)
 .UNINDENT
diff --git a/docs/man/borg-compression.1 b/docs/man/borg-compression.1
index ff348a7e3..52c16fec6 100644
--- a/docs/man/borg-compression.1
+++ b/docs/man/borg-compression.1
@@ -27,7 +27,7 @@ level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .in \\n[rst2man-indent\\n[rst2man-indent-level]]u
 ..
-.TH "BORG-COMPRESSION" 1 "2022-06-25" "" "borg backup tool"
+.TH "BORG-COMPRESSION" 1 "2022-06-26" "" "borg backup tool"
 .SH NAME
 borg-compression \- Details regarding compression
 .SH DESCRIPTION
diff --git a/docs/man/borg-config.1 b/docs/man/borg-config.1
index 35cc426d9..6aa66f922 100644
--- a/docs/man/borg-config.1
+++ b/docs/man/borg-config.1
@@ -27,7 +27,7 @@ level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .in \\n[rst2man-indent\\n[rst2man-indent-level]]u
 ..
-.TH "BORG-CONFIG" 1 "2022-06-25" "" "borg backup tool"
+.TH "BORG-CONFIG" 1 "2022-06-26" "" "borg backup tool"
 .SH NAME
 borg-config \- get, set, and delete values in a repository or cache config file
 .SH SYNOPSIS
diff --git a/docs/man/borg-create.1 b/docs/man/borg-create.1
index 7d36f0940..7c1509ace 100644
--- a/docs/man/borg-create.1
+++ b/docs/man/borg-create.1
@@ -27,7 +27,7 @@ level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .in \\n[rst2man-indent\\n[rst2man-indent-level]]u
 ..
-.TH "BORG-CREATE" 1 "2022-06-25" "" "borg backup tool"
+.TH "BORG-CREATE" 1 "2022-06-26" "" "borg backup tool"
 .SH NAME
 borg-create \- Create new archive
 .SH SYNOPSIS
diff --git a/docs/man/borg-delete.1 b/docs/man/borg-delete.1
index 7a213de1d..7f1e4b05d 100644
--- a/docs/man/borg-delete.1
+++ b/docs/man/borg-delete.1
@@ -27,7 +27,7 @@ level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .in \\n[rst2man-indent\\n[rst2man-indent-level]]u
 ..
-.TH "BORG-DELETE" 1 "2022-06-25" "" "borg backup tool"
+.TH "BORG-DELETE" 1 "2022-06-26" "" "borg backup tool"
 .SH NAME
 borg-delete \- Delete archives
 .SH SYNOPSIS
diff --git a/docs/man/borg-diff.1 b/docs/man/borg-diff.1
index 27b026d29..5f67f8746 100644
--- a/docs/man/borg-diff.1
+++ b/docs/man/borg-diff.1
@@ -27,7 +27,7 @@ level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .in \\n[rst2man-indent\\n[rst2man-indent-level]]u
 ..
-.TH "BORG-DIFF" 1 "2022-06-25" "" "borg backup tool"
+.TH "BORG-DIFF" 1 "2022-06-26" "" "borg backup tool"
 .SH NAME
 borg-diff \- Diff contents of two archives
 .SH SYNOPSIS
diff --git a/docs/man/borg-export-tar.1 b/docs/man/borg-export-tar.1
index 93900a558..609698d7f 100644
--- a/docs/man/borg-export-tar.1
+++ b/docs/man/borg-export-tar.1
@@ -27,7 +27,7 @@ level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .in \\n[rst2man-indent\\n[rst2man-indent-level]]u
 ..
-.TH "BORG-EXPORT-TAR" 1 "2022-06-25" "" "borg backup tool"
+.TH "BORG-EXPORT-TAR" 1 "2022-06-26" "" "borg backup tool"
 .SH NAME
 borg-export-tar \- Export archive contents as a tarball
 .SH SYNOPSIS
diff --git a/docs/man/borg-extract.1 b/docs/man/borg-extract.1
index a5e70b1fd..a8fd1125b 100644
--- a/docs/man/borg-extract.1
+++ b/docs/man/borg-extract.1
@@ -27,7 +27,7 @@ level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .in \\n[rst2man-indent\\n[rst2man-indent-level]]u
 ..
-.TH "BORG-EXTRACT" 1 "2022-06-25" "" "borg backup tool"
+.TH "BORG-EXTRACT" 1 "2022-06-26" "" "borg backup tool"
 .SH NAME
 borg-extract \- Extract archive contents
 .SH SYNOPSIS
diff --git a/docs/man/borg-import-tar.1 b/docs/man/borg-import-tar.1
index 9af05ce3b..fc7e37a92 100644
--- a/docs/man/borg-import-tar.1
+++ b/docs/man/borg-import-tar.1
@@ -27,7 +27,7 @@ level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .in \\n[rst2man-indent\\n[rst2man-indent-level]]u
 ..
-.TH "BORG-IMPORT-TAR" 1 "2022-06-25" "" "borg backup tool"
+.TH "BORG-IMPORT-TAR" 1 "2022-06-26" "" "borg backup tool"
 .SH NAME
 borg-import-tar \- Create a backup archive from a tarball
 .SH SYNOPSIS
diff --git a/docs/man/borg-info.1 b/docs/man/borg-info.1
index fccf6ee69..0daa2ce6c 100644
--- a/docs/man/borg-info.1
+++ b/docs/man/borg-info.1
@@ -27,7 +27,7 @@ level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .in \\n[rst2man-indent\\n[rst2man-indent-level]]u
 ..
-.TH "BORG-INFO" 1 "2022-06-25" "" "borg backup tool"
+.TH "BORG-INFO" 1 "2022-06-26" "" "borg backup tool"
 .SH NAME
 borg-info \- Show archive details such as disk space used
 .SH SYNOPSIS
diff --git a/docs/man/borg-key-change-algorithm.1 b/docs/man/borg-key-change-algorithm.1
index 6308a926b..8178a92b2 100644
--- a/docs/man/borg-key-change-algorithm.1
+++ b/docs/man/borg-key-change-algorithm.1
@@ -27,7 +27,7 @@ level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .in \\n[rst2man-indent\\n[rst2man-indent-level]]u
 ..
-.TH "BORG-KEY-CHANGE-ALGORITHM" 1 "2022-06-25" "" "borg backup tool"
+.TH "BORG-KEY-CHANGE-ALGORITHM" 1 "2022-06-26" "" "borg backup tool"
 .SH NAME
 borg-key-change-algorithm \- Change repository key algorithm
 .SH SYNOPSIS
diff --git a/docs/man/borg-key-change-location.1 b/docs/man/borg-key-change-location.1
index a0b626420..417f0d182 100644
--- a/docs/man/borg-key-change-location.1
+++ b/docs/man/borg-key-change-location.1
@@ -27,7 +27,7 @@ level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .in \\n[rst2man-indent\\n[rst2man-indent-level]]u
 ..
-.TH "BORG-KEY-CHANGE-LOCATION" 1 "2022-06-25" "" "borg backup tool"
+.TH "BORG-KEY-CHANGE-LOCATION" 1 "2022-06-26" "" "borg backup tool"
 .SH NAME
 borg-key-change-location \- Change repository key location
 .SH SYNOPSIS
diff --git a/docs/man/borg-key-change-passphrase.1 b/docs/man/borg-key-change-passphrase.1
index 1a3b169a9..847c5b300 100644
--- a/docs/man/borg-key-change-passphrase.1
+++ b/docs/man/borg-key-change-passphrase.1
@@ -27,7 +27,7 @@ level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .in \\n[rst2man-indent\\n[rst2man-indent-level]]u
 ..
-.TH "BORG-KEY-CHANGE-PASSPHRASE" 1 "2022-06-25" "" "borg backup tool"
+.TH "BORG-KEY-CHANGE-PASSPHRASE" 1 "2022-06-26" "" "borg backup tool"
 .SH NAME
 borg-key-change-passphrase \- Change repository key file passphrase
 .SH SYNOPSIS
diff --git a/docs/man/borg-key-export.1 b/docs/man/borg-key-export.1
index 0405d58f3..55bc248fd 100644
--- a/docs/man/borg-key-export.1
+++ b/docs/man/borg-key-export.1
@@ -27,7 +27,7 @@ level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .in \\n[rst2man-indent\\n[rst2man-indent-level]]u
 ..
-.TH "BORG-KEY-EXPORT" 1 "2022-06-25" "" "borg backup tool"
+.TH "BORG-KEY-EXPORT" 1 "2022-06-26" "" "borg backup tool"
 .SH NAME
 borg-key-export \- Export the repository key for backup
 .SH SYNOPSIS
diff --git a/docs/man/borg-key-import.1 b/docs/man/borg-key-import.1
index cb466d963..d6c190a82 100644
--- a/docs/man/borg-key-import.1
+++ b/docs/man/borg-key-import.1
@@ -27,7 +27,7 @@ level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .in \\n[rst2man-indent\\n[rst2man-indent-level]]u
 ..
-.TH "BORG-KEY-IMPORT" 1 "2022-06-25" "" "borg backup tool"
+.TH "BORG-KEY-IMPORT" 1 "2022-06-26" "" "borg backup tool"
 .SH NAME
 borg-key-import \- Import the repository key from backup
 .SH SYNOPSIS
diff --git a/docs/man/borg-key.1 b/docs/man/borg-key.1
index 82780ff82..e83344501 100644
--- a/docs/man/borg-key.1
+++ b/docs/man/borg-key.1
@@ -27,7 +27,7 @@ level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .in \\n[rst2man-indent\\n[rst2man-indent-level]]u
 ..
-.TH "BORG-KEY" 1 "2022-06-25" "" "borg backup tool"
+.TH "BORG-KEY" 1 "2022-06-26" "" "borg backup tool"
 .SH NAME
 borg-key \- Manage a keyfile or repokey of a repository
 .SH SYNOPSIS
diff --git a/docs/man/borg-list.1 b/docs/man/borg-list.1
index 6b366005d..ee97a0285 100644
--- a/docs/man/borg-list.1
+++ b/docs/man/borg-list.1
@@ -27,7 +27,7 @@ level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .in \\n[rst2man-indent\\n[rst2man-indent-level]]u
 ..
-.TH "BORG-LIST" 1 "2022-06-25" "" "borg backup tool"
+.TH "BORG-LIST" 1 "2022-06-26" "" "borg backup tool"
 .SH NAME
 borg-list \- List archive contents
 .SH SYNOPSIS
diff --git a/docs/man/borg-mount.1 b/docs/man/borg-mount.1
index 4ebbcf753..e16b71dd2 100644
--- a/docs/man/borg-mount.1
+++ b/docs/man/borg-mount.1
@@ -27,7 +27,7 @@ level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .in \\n[rst2man-indent\\n[rst2man-indent-level]]u
 ..
-.TH "BORG-MOUNT" 1 "2022-06-25" "" "borg backup tool"
+.TH "BORG-MOUNT" 1 "2022-06-26" "" "borg backup tool"
 .SH NAME
 borg-mount \- Mount archive or an entire repository as a FUSE filesystem
 .SH SYNOPSIS
diff --git a/docs/man/borg-patterns.1 b/docs/man/borg-patterns.1
index bcf2adf5c..3165853ce 100644
--- a/docs/man/borg-patterns.1
+++ b/docs/man/borg-patterns.1
@@ -27,7 +27,7 @@ level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .in \\n[rst2man-indent\\n[rst2man-indent-level]]u
 ..
-.TH "BORG-PATTERNS" 1 "2022-06-25" "" "borg backup tool"
+.TH "BORG-PATTERNS" 1 "2022-06-26" "" "borg backup tool"
 .SH NAME
 borg-patterns \- Details regarding patterns
 .SH DESCRIPTION
diff --git a/docs/man/borg-placeholders.1 b/docs/man/borg-placeholders.1
index 86d57d485..c22cc3042 100644
--- a/docs/man/borg-placeholders.1
+++ b/docs/man/borg-placeholders.1
@@ -27,7 +27,7 @@ level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .in \\n[rst2man-indent\\n[rst2man-indent-level]]u
 ..
-.TH "BORG-PLACEHOLDERS" 1 "2022-06-25" "" "borg backup tool"
+.TH "BORG-PLACEHOLDERS" 1 "2022-06-26" "" "borg backup tool"
 .SH NAME
 borg-placeholders \- Details regarding placeholders
 .SH DESCRIPTION
diff --git a/docs/man/borg-prune.1 b/docs/man/borg-prune.1
index 0cbb7f772..f15640b7e 100644
--- a/docs/man/borg-prune.1
+++ b/docs/man/borg-prune.1
@@ -27,7 +27,7 @@ level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .in \\n[rst2man-indent\\n[rst2man-indent-level]]u
 ..
-.TH "BORG-PRUNE" 1 "2022-06-25" "" "borg backup tool"
+.TH "BORG-PRUNE" 1 "2022-06-26" "" "borg backup tool"
 .SH NAME
 borg-prune \- Prune repository archives according to specified rules
 .SH SYNOPSIS
diff --git a/docs/man/borg-rcreate.1 b/docs/man/borg-rcreate.1
index 0d500f1d4..3f4efc029 100644
--- a/docs/man/borg-rcreate.1
+++ b/docs/man/borg-rcreate.1
@@ -27,7 +27,7 @@ level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .in \\n[rst2man-indent\\n[rst2man-indent-level]]u
 ..
-.TH "BORG-RCREATE" 1 "2022-06-25" "" "borg backup tool"
+.TH "BORG-RCREATE" 1 "2022-06-26" "" "borg backup tool"
 .SH NAME
 borg-rcreate \- Create a new, empty repository
 .SH SYNOPSIS
diff --git a/docs/man/borg-rdelete.1 b/docs/man/borg-rdelete.1
index 89b837412..d6832c436 100644
--- a/docs/man/borg-rdelete.1
+++ b/docs/man/borg-rdelete.1
@@ -27,7 +27,7 @@ level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .in \\n[rst2man-indent\\n[rst2man-indent-level]]u
 ..
-.TH "BORG-RDELETE" 1 "2022-06-25" "" "borg backup tool"
+.TH "BORG-RDELETE" 1 "2022-06-26" "" "borg backup tool"
 .SH NAME
 borg-rdelete \- Delete a repository
 .SH SYNOPSIS
diff --git a/docs/man/borg-recreate.1 b/docs/man/borg-recreate.1
index 475de0696..1a45294f1 100644
--- a/docs/man/borg-recreate.1
+++ b/docs/man/borg-recreate.1
@@ -27,7 +27,7 @@ level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .in \\n[rst2man-indent\\n[rst2man-indent-level]]u
 ..
-.TH "BORG-RECREATE" 1 "2022-06-25" "" "borg backup tool"
+.TH "BORG-RECREATE" 1 "2022-06-26" "" "borg backup tool"
 .SH NAME
 borg-recreate \- Re-create archives
 .SH SYNOPSIS
diff --git a/docs/man/borg-rename.1 b/docs/man/borg-rename.1
index 0c5c8051e..8e848e5b8 100644
--- a/docs/man/borg-rename.1
+++ b/docs/man/borg-rename.1
@@ -27,7 +27,7 @@ level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .in \\n[rst2man-indent\\n[rst2man-indent-level]]u
 ..
-.TH "BORG-RENAME" 1 "2022-06-25" "" "borg backup tool"
+.TH "BORG-RENAME" 1 "2022-06-26" "" "borg backup tool"
 .SH NAME
 borg-rename \- Rename an existing archive
 .SH SYNOPSIS
diff --git a/docs/man/borg-rinfo.1 b/docs/man/borg-rinfo.1
index ac0306c6a..5982ad19a 100644
--- a/docs/man/borg-rinfo.1
+++ b/docs/man/borg-rinfo.1
@@ -27,7 +27,7 @@ level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .in \\n[rst2man-indent\\n[rst2man-indent-level]]u
 ..
-.TH "BORG-RINFO" 1 "2022-06-25" "" "borg backup tool"
+.TH "BORG-RINFO" 1 "2022-06-26" "" "borg backup tool"
 .SH NAME
 borg-rinfo \- Show repository infos
 .SH SYNOPSIS
diff --git a/docs/man/borg-rlist.1 b/docs/man/borg-rlist.1
index d85a1ff85..b5b7b29c0 100644
--- a/docs/man/borg-rlist.1
+++ b/docs/man/borg-rlist.1
@@ -27,7 +27,7 @@ level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .in \\n[rst2man-indent\\n[rst2man-indent-level]]u
 ..
-.TH "BORG-RLIST" 1 "2022-06-25" "" "borg backup tool"
+.TH "BORG-RLIST" 1 "2022-06-26" "" "borg backup tool"
 .SH NAME
 borg-rlist \- List the archives contained in a repository
 .SH SYNOPSIS
diff --git a/docs/man/borg-serve.1 b/docs/man/borg-serve.1
index 3660920ba..ee6acff53 100644
--- a/docs/man/borg-serve.1
+++ b/docs/man/borg-serve.1
@@ -27,7 +27,7 @@ level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .in \\n[rst2man-indent\\n[rst2man-indent-level]]u
 ..
-.TH "BORG-SERVE" 1 "2022-06-25" "" "borg backup tool"
+.TH "BORG-SERVE" 1 "2022-06-26" "" "borg backup tool"
 .SH NAME
 borg-serve \- Start in server mode. This command is usually not used manually.
 .SH SYNOPSIS
diff --git a/docs/man/borg-transfer.1 b/docs/man/borg-transfer.1
index 6832973a9..f3ca8078e 100644
--- a/docs/man/borg-transfer.1
+++ b/docs/man/borg-transfer.1
@@ -27,7 +27,7 @@ level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .in \\n[rst2man-indent\\n[rst2man-indent-level]]u
 ..
-.TH "BORG-TRANSFER" 1 "2022-06-25" "" "borg backup tool"
+.TH "BORG-TRANSFER" 1 "2022-06-26" "" "borg backup tool"
 .SH NAME
 borg-transfer \- archives transfer from other repository
 .SH SYNOPSIS
@@ -91,6 +91,60 @@ consider first N archives after other filters were applied
 .BI \-\-last \ N
 consider last N archives after other filters were applied
 .UNINDENT
+.SH EXAMPLES
+.INDENT 0.0
+.TP
+.B ::
+# 0. Have borg 2.0 installed on client AND server, have a b12 repo copy for testing.
+.sp
+# 1. Create a new "related" repository:
+# here, the existing borg 1.2 repo used repokey\-blake2 (and aes\-ctr mode),
+# thus we use repokey\-blake2\-aes\-ocb for the new borg 2.0 repo.
+# staying with the same chunk id algorithm (blake2) and with the same
+# key material (via \-\-other\-repo <oldrepo>) will make deduplication work
+# between old archives (copied with borg transfer) and future ones.
+# the AEAD cipher does not matter (everything must be re\-encrypted and
+# re\-authenticated anyway), you could also choose repokey\-blake2\-chacha20\-poly1305.
+# in case your old borg repo did not use blake2, just remove the "\-blake2".
+$ borg \-\-repo       \fI\%ssh://borg2@borgbackup/./tests/b20\fP rcreate 
+.IP "System Message: ERROR/3 (docs/borg-transfer.rst:, line 88)"
+Unexpected indentation.
+.INDENT 7.0
+.INDENT 3.5
+\-\-other\-repo \fI\%ssh://borg2@borgbackup/./tests/b12\fP \-e repokey\-blake2\-aes\-ocb
+.UNINDENT
+.UNINDENT
+.sp
+# 2. Check what and how much it would transfer:
+$ borg \-\-repo       \fI\%ssh://borg2@borgbackup/./tests/b20\fP transfer 
+.IP "System Message: ERROR/3 (docs/borg-transfer.rst:, line 92)"
+Unexpected indentation.
+.INDENT 7.0
+.INDENT 3.5
+\-\-other\-repo \fI\%ssh://borg2@borgbackup/./tests/b12\fP \-\-dry\-run
+.UNINDENT
+.UNINDENT
+.sp
+# 3. Transfer (copy) archives from old repo into new repo (takes time and space!):
+$ borg \-\-repo       \fI\%ssh://borg2@borgbackup/./tests/b20\fP transfer 
+.IP "System Message: ERROR/3 (docs/borg-transfer.rst:, line 96)"
+Unexpected indentation.
+.INDENT 7.0
+.INDENT 3.5
+\-\-other\-repo \fI\%ssh://borg2@borgbackup/./tests/b12\fP
+.UNINDENT
+.UNINDENT
+.sp
+# 4. Check if we have everything (same as 2.):
+$ borg \-\-repo       \fI\%ssh://borg2@borgbackup/./tests/b20\fP transfer 
+.IP "System Message: ERROR/3 (docs/borg-transfer.rst:, line 100)"
+Unexpected indentation.
+.INDENT 7.0
+.INDENT 3.5
+\-\-other\-repo \fI\%ssh://borg2@borgbackup/./tests/b12\fP \-\-dry\-run
+.UNINDENT
+.UNINDENT
+.UNINDENT
 .SH SEE ALSO
 .sp
 \fIborg\-common(1)\fP
diff --git a/docs/man/borg-umount.1 b/docs/man/borg-umount.1
index 24b62fc95..6694cf15c 100644
--- a/docs/man/borg-umount.1
+++ b/docs/man/borg-umount.1
@@ -27,7 +27,7 @@ level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .in \\n[rst2man-indent\\n[rst2man-indent-level]]u
 ..
-.TH "BORG-UMOUNT" 1 "2022-06-25" "" "borg backup tool"
+.TH "BORG-UMOUNT" 1 "2022-06-26" "" "borg backup tool"
 .SH NAME
 borg-umount \- un-mount the FUSE filesystem
 .SH SYNOPSIS
diff --git a/docs/man/borg-with-lock.1 b/docs/man/borg-with-lock.1
index a3cca32e9..dc146b44d 100644
--- a/docs/man/borg-with-lock.1
+++ b/docs/man/borg-with-lock.1
@@ -27,7 +27,7 @@ level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .in \\n[rst2man-indent\\n[rst2man-indent-level]]u
 ..
-.TH "BORG-WITH-LOCK" 1 "2022-06-25" "" "borg backup tool"
+.TH "BORG-WITH-LOCK" 1 "2022-06-26" "" "borg backup tool"
 .SH NAME
 borg-with-lock \- run a user specified command with the repository lock held
 .SH SYNOPSIS
diff --git a/docs/man/borg.1 b/docs/man/borg.1
index 16bfdddf1..398c31a3e 100644
--- a/docs/man/borg.1
+++ b/docs/man/borg.1
@@ -27,7 +27,7 @@ level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .in \\n[rst2man-indent\\n[rst2man-indent-level]]u
 ..
-.TH "BORG" 1 "2022-06-25" "" "borg backup tool"
+.TH "BORG" 1 "2022-06-26" "" "borg backup tool"
 .SH NAME
 borg \- deduplicating and encrypting backup tool
 .SH SYNOPSIS
diff --git a/docs/man/borgfs.1 b/docs/man/borgfs.1
index 1225418ce..1bad87165 100644
--- a/docs/man/borgfs.1
+++ b/docs/man/borgfs.1
@@ -27,7 +27,7 @@ level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .in \\n[rst2man-indent\\n[rst2man-indent-level]]u
 ..
-.TH "BORGFS" 1 "2022-06-25" "" "borg backup tool"
+.TH "BORGFS" 1 "2022-06-26" "" "borg backup tool"
 .SH NAME
 borgfs \- Mount archive or an entire repository as a FUSE filesystem
 .SH SYNOPSIS
diff --git a/docs/usage/check.rst.inc b/docs/usage/check.rst.inc
index 948f4d63b..e6bb5dcb4 100644
--- a/docs/usage/check.rst.inc
+++ b/docs/usage/check.rst.inc
@@ -15,8 +15,6 @@ borg check
     +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------+
     | **optional arguments**                                                                                                                                                                                                                                                       |
     +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------+
-    |                                                                             | ``--name NAME``                       | specify the archive name                                                                                                                               |
-    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------+
     |                                                                             | ``--repository-only``                 | only perform repository checks                                                                                                                         |
     +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------+
     |                                                                             | ``--archives-only``                   | only perform archives checks                                                                                                                           |
@@ -59,7 +57,6 @@ borg check
 
 
     optional arguments
-        --name NAME       specify the archive name
         --repository-only    only perform repository checks
         --archives-only    only perform archives checks
         --verify-data     perform cryptographic archive data integrity verification (conflicts with ``--repository-only``)
diff --git a/docs/usage/compact.rst.inc b/docs/usage/compact.rst.inc
index d9614fb4a..946b376fc 100644
--- a/docs/usage/compact.rst.inc
+++ b/docs/usage/compact.rst.inc
@@ -15,8 +15,6 @@ borg compact
     +-------------------------------------------------------+-------------------------+----------------------------------------------------------------+
     | **optional arguments**                                                                                                                           |
     +-------------------------------------------------------+-------------------------+----------------------------------------------------------------+
-    |                                                       | ``--cleanup-commits``   | cleanup commit-only 17-byte segment files                      |
-    +-------------------------------------------------------+-------------------------+----------------------------------------------------------------+
     |                                                       | ``--threshold PERCENT`` | set minimum threshold for saved space in PERCENT (Default: 10) |
     +-------------------------------------------------------+-------------------------+----------------------------------------------------------------+
     | .. class:: borg-common-opt-ref                                                                                                                   |
@@ -37,7 +35,6 @@ borg compact
 
 
     optional arguments
-        --cleanup-commits       cleanup commit-only 17-byte segment files
         --threshold PERCENT     set minimum threshold for saved space in PERCENT (Default: 10)
 
 
@@ -63,9 +60,4 @@ A segment is compacted if the amount of saved space is above the percentage valu
 given by the ``--threshold`` option. If omitted, a threshold of 10% is used.
 When using ``--verbose``, borg will output an estimate of the freed space.
 
-After upgrading borg (server) to 1.2+, you can use ``borg compact --cleanup-commits``
-to clean up the numerous 17byte commit-only segments that borg 1.1 did not clean up
-due to a bug. It is enough to do that once per repository. After cleaning up the
-commits, borg will also do a normal compaction.
-
 See :ref:`separate_compaction` in Additional Notes for more details.
\ No newline at end of file

From a98c6ba479f1e8df406c28177af342d2b05dd633 Mon Sep 17 00:00:00 2001
From: Thomas Waldmann <tw@waldmann-edv.de>
Date: Sun, 26 Jun 2022 19:59:08 +0200
Subject: [PATCH 080/160] changes: init -> rcreate

---
 docs/changes.rst | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/changes.rst b/docs/changes.rst
index 669ef3c0e..4073ee83c 100644
--- a/docs/changes.rst
+++ b/docs/changes.rst
@@ -90,7 +90,7 @@ Changes:
 
   - symmetric hlid (all hardlinks pointing to same inode have same hlid)
   - all archived hardlinked regular files have a chunks list
-- borg init --other-repo=OTHER_REPO: reuse key material from OTHER_REPO, #6554.
+- borg rcreate --other-repo=OTHER_REPO: reuse key material from OTHER_REPO, #6554.
   This is useful if you want to use borg transfer to transfer archives from an
   existing borg 1.1/1.2 repo. If the chunker secret and the id key and algorithm
   stay the same, the deduplication will also work between past and future backups.

From 9680538a70fd940290f1cb2bffb63c474be28a4a Mon Sep 17 00:00:00 2001
From: Thomas Waldmann <tw@waldmann-edv.de>
Date: Sun, 26 Jun 2022 20:06:58 +0200
Subject: [PATCH 081/160] fix rendering of list/rlist help

---
 docs/man/borg-list.1     | 23 ++++++++++++++++-------
 docs/man/borg-rlist.1    | 23 ++++++++++++++++-------
 docs/usage/list.rst.inc  |  1 +
 docs/usage/rlist.rst.inc |  1 +
 src/borg/archiver.py     |  2 ++
 5 files changed, 36 insertions(+), 14 deletions(-)

diff --git a/docs/man/borg-list.1 b/docs/man/borg-list.1
index ee97a0285..8a40d16b1 100644
--- a/docs/man/borg-list.1
+++ b/docs/man/borg-list.1
@@ -144,13 +144,22 @@ $ borg list \-\-format \(aq{mode} {user:>6} {group:>6} {size:<8} {mtime} {path}{
 .UNINDENT
 .sp
 The following keys are always available:
-\- NEWLINE: OS dependent line separator
-\- NL: alias of NEWLINE
-\- NUL: NUL character for creating print0 / xargs \-0 like output, see barchive and bpath keys below
-\- SPACE
-\- TAB
-\- CR
-\- LF
+.INDENT 0.0
+.IP \(bu 2
+NEWLINE: OS dependent line separator
+.IP \(bu 2
+NL: alias of NEWLINE
+.IP \(bu 2
+NUL: NUL character for creating print0 / xargs \-0 like output, see barchive and bpath keys below
+.IP \(bu 2
+SPACE
+.IP \(bu 2
+TAB
+.IP \(bu 2
+CR
+.IP \(bu 2
+LF
+.UNINDENT
 .sp
 Keys available only when listing files in an archive:
 .INDENT 0.0
diff --git a/docs/man/borg-rlist.1 b/docs/man/borg-rlist.1
index b5b7b29c0..1511e6f6b 100644
--- a/docs/man/borg-rlist.1
+++ b/docs/man/borg-rlist.1
@@ -116,13 +116,22 @@ ArchiveFoo                           Thu, 2021\-12\-09 10:22:28 [0b8e9a312bef3f2
 .UNINDENT
 .sp
 The following keys are always available:
-\- NEWLINE: OS dependent line separator
-\- NL: alias of NEWLINE
-\- NUL: NUL character for creating print0 / xargs \-0 like output, see barchive and bpath keys below
-\- SPACE
-\- TAB
-\- CR
-\- LF
+.INDENT 0.0
+.IP \(bu 2
+NEWLINE: OS dependent line separator
+.IP \(bu 2
+NL: alias of NEWLINE
+.IP \(bu 2
+NUL: NUL character for creating print0 / xargs \-0 like output, see barchive and bpath keys below
+.IP \(bu 2
+SPACE
+.IP \(bu 2
+TAB
+.IP \(bu 2
+CR
+.IP \(bu 2
+LF
+.UNINDENT
 .sp
 Keys available only when listing archives in a repository:
 .INDENT 0.0
diff --git a/docs/usage/list.rst.inc b/docs/usage/list.rst.inc
index 4d17543ee..995e2431e 100644
--- a/docs/usage/list.rst.inc
+++ b/docs/usage/list.rst.inc
@@ -103,6 +103,7 @@ Examples:
     ...
 
 The following keys are always available:
+
 - NEWLINE: OS dependent line separator
 - NL: alias of NEWLINE
 - NUL: NUL character for creating print0 / xargs -0 like output, see barchive and bpath keys below
diff --git a/docs/usage/rlist.rst.inc b/docs/usage/rlist.rst.inc
index 335fc629d..0fec78a3a 100644
--- a/docs/usage/rlist.rst.inc
+++ b/docs/usage/rlist.rst.inc
@@ -99,6 +99,7 @@ Examples:
     ...
 
 The following keys are always available:
+
 - NEWLINE: OS dependent line separator
 - NL: alias of NEWLINE
 - NUL: NUL character for creating print0 / xargs -0 like output, see barchive and bpath keys below
diff --git a/src/borg/archiver.py b/src/borg/archiver.py
index 0cfbe3adf..6e31e9dd4 100644
--- a/src/borg/archiver.py
+++ b/src/borg/archiver.py
@@ -4653,6 +4653,7 @@ class Archiver:
 
         The following keys are always available:
 
+
         """) + BaseFormatter.keys_help() + textwrap.dedent("""
 
         Keys available only when listing files in an archive:
@@ -4710,6 +4711,7 @@ class Archiver:
 
         The following keys are always available:
 
+
         """) + BaseFormatter.keys_help() + textwrap.dedent("""
 
         Keys available only when listing archives in a repository:

From e2f7087aa838aea72280612c81d9eb64719b496e Mon Sep 17 00:00:00 2001
From: Thomas Waldmann <tw@waldmann-edv.de>
Date: Sun, 26 Jun 2022 20:09:54 +0200
Subject: [PATCH 082/160] docs: remove reference to borg upgrade

---
 docs/usage/general/file-systems.rst.inc | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/docs/usage/general/file-systems.rst.inc b/docs/usage/general/file-systems.rst.inc
index 60b7f46f9..7a022899c 100644
--- a/docs/usage/general/file-systems.rst.inc
+++ b/docs/usage/general/file-systems.rst.inc
@@ -26,6 +26,5 @@ and readable after one of the failures mentioned above occurred, run
   it should be a move (not a copy) operation, and in case of a directory
   it should fail if the destination exists and is not an empty directory,
   since this is used for locking.
-- Hardlinks are needed for :ref:`borg_upgrade` (if ``--inplace`` option is not used).
-  Also hardlinks are used for more safe and secure file updating (e.g. of the repo
+- Also hardlinks are used for more safe and secure file updating (e.g. of the repo
   config file), but the code tries to work also if hardlinks are not supported.

From 0a7baa53c463f9b352c2619565f1c1391b9fc608 Mon Sep 17 00:00:00 2001
From: Thomas Waldmann <tw@waldmann-edv.de>
Date: Sun, 26 Jun 2022 20:11:41 +0200
Subject: [PATCH 083/160] docs: fix borg transfer formatting / rendering, fixes
 #6800

---
 docs/man/borg-transfer.1 | 55 +++++++++++++---------------------------
 docs/man/borg.1          |  1 -
 docs/usage/transfer.rst  |  1 +
 3 files changed, 19 insertions(+), 38 deletions(-)

diff --git a/docs/man/borg-transfer.1 b/docs/man/borg-transfer.1
index f3ca8078e..348bc8089 100644
--- a/docs/man/borg-transfer.1
+++ b/docs/man/borg-transfer.1
@@ -93,10 +93,12 @@ consider last N archives after other filters were applied
 .UNINDENT
 .SH EXAMPLES
 .INDENT 0.0
-.TP
-.B ::
-# 0. Have borg 2.0 installed on client AND server, have a b12 repo copy for testing.
+.INDENT 3.5
 .sp
+.nf
+.ft C
+# 0. Have borg 2.0 installed on client AND server, have a b12 repo copy for testing.
+
 # 1. Create a new "related" repository:
 # here, the existing borg 1.2 repo used repokey\-blake2 (and aes\-ctr mode),
 # thus we use repokey\-blake2\-aes\-ocb for the new borg 2.0 repo.
@@ -106,43 +108,22 @@ consider last N archives after other filters were applied
 # the AEAD cipher does not matter (everything must be re\-encrypted and
 # re\-authenticated anyway), you could also choose repokey\-blake2\-chacha20\-poly1305.
 # in case your old borg repo did not use blake2, just remove the "\-blake2".
-$ borg \-\-repo       \fI\%ssh://borg2@borgbackup/./tests/b20\fP rcreate 
-.IP "System Message: ERROR/3 (docs/borg-transfer.rst:, line 88)"
-Unexpected indentation.
-.INDENT 7.0
-.INDENT 3.5
-\-\-other\-repo \fI\%ssh://borg2@borgbackup/./tests/b12\fP \-e repokey\-blake2\-aes\-ocb
-.UNINDENT
-.UNINDENT
-.sp
+$ borg \-\-repo       ssh://borg2@borgbackup/./tests/b20 rcreate \e
+       \-\-other\-repo ssh://borg2@borgbackup/./tests/b12 \-e repokey\-blake2\-aes\-ocb
+
 # 2. Check what and how much it would transfer:
-$ borg \-\-repo       \fI\%ssh://borg2@borgbackup/./tests/b20\fP transfer 
-.IP "System Message: ERROR/3 (docs/borg-transfer.rst:, line 92)"
-Unexpected indentation.
-.INDENT 7.0
-.INDENT 3.5
-\-\-other\-repo \fI\%ssh://borg2@borgbackup/./tests/b12\fP \-\-dry\-run
-.UNINDENT
-.UNINDENT
-.sp
+$ borg \-\-repo       ssh://borg2@borgbackup/./tests/b20 transfer \e
+       \-\-other\-repo ssh://borg2@borgbackup/./tests/b12 \-\-dry\-run
+
 # 3. Transfer (copy) archives from old repo into new repo (takes time and space!):
-$ borg \-\-repo       \fI\%ssh://borg2@borgbackup/./tests/b20\fP transfer 
-.IP "System Message: ERROR/3 (docs/borg-transfer.rst:, line 96)"
-Unexpected indentation.
-.INDENT 7.0
-.INDENT 3.5
-\-\-other\-repo \fI\%ssh://borg2@borgbackup/./tests/b12\fP
-.UNINDENT
-.UNINDENT
-.sp
+$ borg \-\-repo       ssh://borg2@borgbackup/./tests/b20 transfer \e
+       \-\-other\-repo ssh://borg2@borgbackup/./tests/b12
+
 # 4. Check if we have everything (same as 2.):
-$ borg \-\-repo       \fI\%ssh://borg2@borgbackup/./tests/b20\fP transfer 
-.IP "System Message: ERROR/3 (docs/borg-transfer.rst:, line 100)"
-Unexpected indentation.
-.INDENT 7.0
-.INDENT 3.5
-\-\-other\-repo \fI\%ssh://borg2@borgbackup/./tests/b12\fP \-\-dry\-run
-.UNINDENT
+$ borg \-\-repo       ssh://borg2@borgbackup/./tests/b20 transfer \e
+       \-\-other\-repo ssh://borg2@borgbackup/./tests/b12 \-\-dry\-run
+.ft P
+.fi
 .UNINDENT
 .UNINDENT
 .SH SEE ALSO
diff --git a/docs/man/borg.1 b/docs/man/borg.1
index 398c31a3e..9cd0d58a7 100644
--- a/docs/man/borg.1
+++ b/docs/man/borg.1
@@ -615,7 +615,6 @@ it should be a move (not a copy) operation, and in case of a directory
 it should fail if the destination exists and is not an empty directory,
 since this is used for locking.
 .IP \(bu 2
-Hardlinks are needed for \fIborg_upgrade\fP (if \fB\-\-inplace\fP option is not used).
 Also hardlinks are used for more safe and secure file updating (e.g. of the repo
 config file), but the code tries to work also if hardlinks are not supported.
 .UNINDENT
diff --git a/docs/usage/transfer.rst b/docs/usage/transfer.rst
index 45af40bee..45f370b8c 100644
--- a/docs/usage/transfer.rst
+++ b/docs/usage/transfer.rst
@@ -3,6 +3,7 @@
 Examples
 ~~~~~~~~
 ::
+
     # 0. Have borg 2.0 installed on client AND server, have a b12 repo copy for testing.
 
     # 1. Create a new "related" repository:

From f749d0dccff664aa3f46c638e880963dcdd49838 Mon Sep 17 00:00:00 2001
From: Thomas Waldmann <tw@waldmann-edv.de>
Date: Tue, 28 Jun 2022 13:35:36 +0200
Subject: [PATCH 084/160] macOS does not support hardlinking symlinks, fixes
 #6802

---
 src/borg/testsuite/archiver.py | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/borg/testsuite/archiver.py b/src/borg/testsuite/archiver.py
index 54c4fdaa4..f7b11206a 100644
--- a/src/borg/testsuite/archiver.py
+++ b/src/borg/testsuite/archiver.py
@@ -56,7 +56,7 @@ from ..repository import Repository
 from . import has_lchflags, llfuse
 from . import BaseTestCase, changedir, environment_variable, no_selinux
 from . import are_symlinks_supported, are_hardlinks_supported, are_fifos_supported, is_utime_fully_supported, is_birthtime_fully_supported
-from .platform import fakeroot_detected
+from .platform import fakeroot_detected, is_darwin
 from . import key
 
 
@@ -505,8 +505,8 @@ class ArchiverTestCase(ArchiverTestCaseBase):
             self.cmd(f'--repo={self.repository_location}', 'extract', 'test')
             assert os.readlink('input/link1') == 'somewhere'
 
-    @pytest.mark.skipif(not are_symlinks_supported() or not are_hardlinks_supported(),
-                        reason='symlinks or hardlinks not supported')
+    @pytest.mark.skipif(not are_symlinks_supported() or not are_hardlinks_supported() or is_darwin,
+                        reason='symlinks or hardlinks or hardlinked symlinks not supported')
     def test_hardlinked_symlinks_extract(self):
         self.create_regular_file('target', size=1024)
         with changedir('input'):

From b5aebcc2539109c617e8983c88739ebb0d61dfe8 Mon Sep 17 00:00:00 2001
From: Thomas Waldmann <tw@waldmann-edv.de>
Date: Tue, 28 Jun 2022 15:47:35 +0200
Subject: [PATCH 085/160] remove remainders of old borg/attic upgrader

---
 src/borg/archiver.py |  1 -
 src/borg/upgrader.py | 56 --------------------------------------------
 2 files changed, 57 deletions(-)

diff --git a/src/borg/archiver.py b/src/borg/archiver.py
index 6e31e9dd4..fe6840039 100644
--- a/src/borg/archiver.py
+++ b/src/borg/archiver.py
@@ -88,7 +88,6 @@ try:
     from .remote import RepositoryServer, RemoteRepository, cache_if_remote
     from .repository import Repository, LIST_SCAN_LIMIT, TAG_PUT, TAG_DELETE, TAG_COMMIT
     from .selftest import selftest
-    from .upgrader import BorgRepositoryUpgrader
 except BaseException:
     # an unhandled exception in the try-block would cause the borg cli command to exit with rc 1 due to python's
     # default behavior, see issue #4424.
diff --git a/src/borg/upgrader.py b/src/borg/upgrader.py
index 68e4c6af5..e69de29bb 100644
--- a/src/borg/upgrader.py
+++ b/src/borg/upgrader.py
@@ -1,56 +0,0 @@
-import os
-
-from .crypto.key import KeyfileKey, KeyfileNotFoundError
-from .helpers import get_base_dir, get_keys_dir
-from .logger import create_logger
-from .repository import Repository
-
-logger = create_logger(__name__)
-
-
-class BorgRepositoryUpgrader(Repository):
-    def upgrade(self, dryrun=True, inplace=False, progress=False):
-        """convert an old borg repository to a current borg repository
-        """
-        logger.info("converting borg 0.xx to borg current")
-        with self:
-            try:
-                keyfile = self.find_borg0xx_keyfile()
-            except KeyfileNotFoundError:
-                logger.warning("no key file found for repository")
-            else:
-                self.move_keyfiles(keyfile, dryrun)
-
-    def find_borg0xx_keyfile(self):
-        return Borg0xxKeyfileKey.find_key_file(self)
-
-    def move_keyfiles(self, keyfile, dryrun):
-        filename = os.path.basename(keyfile)
-        new_keyfile = os.path.join(get_keys_dir(), filename)
-        try:
-            os.rename(keyfile, new_keyfile)
-        except FileExistsError:
-            pass
-
-
-class Borg0xxKeyfileKey(KeyfileKey):
-    """backwards compatible borg 0.xx key file parser"""
-
-    @staticmethod
-    def get_keys_dir():
-        return os.environ.get('BORG_KEYS_DIR',
-                              os.path.join(get_base_dir(), '.borg', 'keys'))
-
-    @classmethod
-    def find_key_file(cls, repository):
-        get_keys_dir = cls.get_keys_dir
-        keys_dir = get_keys_dir()
-        if not os.path.exists(keys_dir):
-            raise KeyfileNotFoundError(repository.path, keys_dir)
-        for name in os.listdir(keys_dir):
-            filename = os.path.join(keys_dir, name)
-            with open(filename) as fd:
-                line = fd.readline().strip()
-                if line and line.startswith(cls.FILE_ID) and line[len(cls.FILE_ID) + 1:] == repository.id_str:
-                    return filename
-        raise KeyfileNotFoundError(repository.path, keys_dir)

From 5d8b29a93f46aaae6937c424129deb4084bfb82d Mon Sep 17 00:00:00 2001
From: Thomas Waldmann <tw@waldmann-edv.de>
Date: Tue, 28 Jun 2022 15:09:18 +0200
Subject: [PATCH 086/160] transfer: --upgrader=NoOp is the default

This is to support general-purpose transfer of archives between related
borg2 repos.

To transfer (and convert) archives from borg 1.2 repos, users need to
give --upgrader=From12To20 .
---
 src/borg/archiver.py |  97 +++++++++++---------------------------
 src/borg/upgrade.py  | 108 +++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 134 insertions(+), 71 deletions(-)
 create mode 100644 src/borg/upgrade.py

diff --git a/src/borg/archiver.py b/src/borg/archiver.py
index fe6840039..8f7c4e449 100644
--- a/src/borg/archiver.py
+++ b/src/borg/archiver.py
@@ -347,72 +347,22 @@ class Archiver:
     def do_transfer(self, args, *,
                repository, manifest, key, cache,
                other_repository=None, other_manifest=None, other_key=None):
-        """archives transfer from other repository"""
-
-        ITEM_KEY_WHITELIST = {'path', 'source', 'rdev', 'chunks', 'chunks_healthy', 'hlid',
-                              'mode', 'user', 'group', 'uid', 'gid', 'mtime', 'atime', 'ctime', 'birthtime', 'size',
-                              'xattrs', 'bsdflags', 'acl_nfs4', 'acl_access', 'acl_default', 'acl_extended',
-                              'part'}
-
-        def upgrade_item(item):
-            """upgrade item as needed, get rid of legacy crap"""
-            if hlm.borg1_hardlink_master(item):
-                item._dict['hlid'] = hlid = hlm.hardlink_id_from_path(item._dict['path'])
-                hlm.remember(id=hlid, info=(item._dict.get('chunks'), item._dict.get('chunks_healthy')))
-            elif hlm.borg1_hardlink_slave(item):
-                item._dict['hlid'] = hlid = hlm.hardlink_id_from_path(item._dict['source'])
-                chunks, chunks_healthy = hlm.retrieve(id=hlid, default=(None, None))
-                if chunks is not None:
-                    item._dict['chunks'] = chunks
-                    for chunk_id, _ in chunks:
-                        cache.chunk_incref(chunk_id, archive.stats)
-                if chunks_healthy is not None:
-                    item._dict['chunks_healthy'] = chunks
-                item._dict.pop('source')  # not used for hardlinks any more, replaced by hlid
-            # make sure we only have desired stuff in the new item. specifically, make sure to get rid of:
-            # - 'acl' remnants of bug in attic <= 0.13
-            # - 'hardlink_master' (superseded by hlid)
-            new_item_dict = {key: value for key, value in item.as_dict().items() if key in ITEM_KEY_WHITELIST}
-            new_item = Item(internal_dict=new_item_dict)
-            new_item.get_size(memorize=True)  # if not already present: compute+remember size for items with chunks
-            assert all(key in new_item for key in REQUIRED_ITEM_KEYS)
-            return new_item
-
-        def upgrade_compressed_chunk(chunk):
-            def upgrade_zlib_and_level(chunk):
-                if ZLIB_legacy.detect(chunk):
-                    ctype = ZLIB.ID
-                    chunk = ctype + level + chunk  # get rid of the attic legacy: prepend separate type/level bytes
-                else:
-                    ctype = chunk[0:1]
-                    chunk = ctype + level + chunk[2:]  # keep type same, but set level
-                return chunk
-
-            ctype = chunk[0:1]
-            level = b'\xFF'  # FF means unknown compression level
-
-            if ctype == ObfuscateSize.ID:
-                # in older borg, we used unusual byte order
-                old_header_fmt = Struct('>I')
-                new_header_fmt = ObfuscateSize.header_fmt
-                length = ObfuscateSize.header_len
-                size_bytes = chunk[2:2+length]
-                size = old_header_fmt.unpack(size_bytes)
-                size_bytes = new_header_fmt.pack(size)
-                compressed = chunk[2+length:]
-                compressed = upgrade_zlib_and_level(compressed)
-                chunk = ctype + level + size_bytes + compressed
-            else:
-                chunk = upgrade_zlib_and_level(chunk)
-            return chunk
-
+        """archives transfer from other repository, optionally upgrade data format"""
         dry_run = args.dry_run
-
         args.consider_checkpoints = True
         archive_names = tuple(x.name for x in other_manifest.archives.list_considering(args))
         if not archive_names:
             return EXIT_SUCCESS
 
+        from . import upgrade as upgrade_mod
+        try:
+            UpgraderCls = getattr(upgrade_mod, f'Upgrader{args.upgrader}')
+        except AttributeError:
+            self.print_error(f'No such upgrader: {args.upgrader}')
+            return EXIT_ERROR
+
+        upgrader = UpgraderCls(cache=cache)
+
         for name in archive_names:
             transfer_size = 0
             present_size = 0
@@ -421,9 +371,9 @@ class Archiver:
             else:
                 if not dry_run:
                     print(f"{name}: copying archive to destination repo...")
-                hlm = HardLinkManager(id_type=bytes, info_type=tuple)  # hlid -> (chunks, chunks_healthy)
                 other_archive = Archive(other_repository, other_key, other_manifest, name)
                 archive = Archive(repository, key, manifest, name, cache=cache, create=True) if not dry_run else None
+                upgrader.new_archive(archive=archive)
                 for item in other_archive.iter_items():
                     if 'chunks' in item:
                         chunks = []
@@ -434,7 +384,7 @@ class Archiver:
                                     cdata = other_repository.get(chunk_id)
                                     # keep compressed payload same, avoid decompression / recompression
                                     data = other_key.decrypt(chunk_id, cdata, decompress=False)
-                                    data = upgrade_compressed_chunk(data)
+                                    data = upgrader.upgrade_compressed_chunk(chunk=data)
                                     chunk_entry = cache.add_chunk(chunk_id, data, archive.stats, wait=False,
                                                                   compress=False, size=size)
                                     cache.repository.async_response(wait=False)
@@ -449,15 +399,9 @@ class Archiver:
                             item.chunks = chunks  # TODO: overwrite? IDs and sizes are same.
                             archive.stats.nfiles += 1
                     if not dry_run:
-                        archive.add_item(upgrade_item(item))
+                        archive.add_item(upgrader.upgrade_item(item=item))
                 if not dry_run:
-                    additional_metadata = {}
-                    # keep all metadata except archive version and stats. also do not keep
-                    # recreate_source_id, recreate_args, recreate_partial_chunks which were used only in 1.1.0b1 .. b2.
-                    for attr in ('cmdline', 'hostname', 'username', 'time', 'time_end', 'comment',
-                                 'chunker_params', 'recreate_cmdline'):
-                        if hasattr(other_archive.metadata, attr):
-                            additional_metadata[attr] = getattr(other_archive.metadata, attr)
+                    additional_metadata = upgrader.upgrade_archive_metadata(metadata=other_archive.metadata)
                     archive.save(stats=archive.stats, additional_metadata=additional_metadata)
                     print(f"{name}: finished. "
                           f"transfer_size: {format_file_size(transfer_size)} "
@@ -4057,8 +4001,9 @@ class Archiver:
         # borg transfer
         transfer_epilog = process_epilog("""
         This command transfers archives from one repository to another repository.
+        Optionally, it can also upgrade the transferred data.
 
-        Suggested use::
+        Suggested use for general purpose archive transfer (not repo upgrades)::
 
             # initialize DST_REPO reusing key material from SRC_REPO, so that
             # chunking and chunk id generation will work in the same way as before.
@@ -4074,6 +4019,13 @@ class Archiver:
         You could use the misc. archive filter options to limit which archives it will
         transfer, e.g. using the -a option. This is recommended for big
         repositories with multiple data sets to keep the runtime per invocation lower.
+
+        For repository upgrades (e.g. from a borg 1.2 repo to a related borg 2.0 repo), usage is
+        quite similar to the above::
+
+            borg --repo=DST_REPO transfer --other-repo=SRC_REPO --upgrader=From12To20
+
+
         """)
         subparser = subparsers.add_parser('transfer', parents=[common_parser], add_help=False,
                                           description=self.do_transfer.__doc__,
@@ -4086,6 +4038,9 @@ class Archiver:
         subparser.add_argument('--other-repo', metavar='SRC_REPOSITORY', dest='other_location',
                                type=location_validator(other=True), default=Location(other=True),
                                help='transfer archives from the other repository')
+        subparser.add_argument('--upgrader', metavar='UPGRADER', dest='upgrader',
+                               type=str, default='NoOp',
+                               help='use the upgrader to convert transferred data (default: no conversion)')
         define_archive_filters_group(subparser)
 
         # borg diff
diff --git a/src/borg/upgrade.py b/src/borg/upgrade.py
new file mode 100644
index 000000000..2f88d791f
--- /dev/null
+++ b/src/borg/upgrade.py
@@ -0,0 +1,108 @@
+from struct import Struct
+
+from .constants import REQUIRED_ITEM_KEYS
+from .compress import ZLIB, ZLIB_legacy, ObfuscateSize
+from .helpers import HardLinkManager
+from .item import Item
+from .logger import create_logger
+
+logger = create_logger(__name__)
+
+
+class UpgraderNoOp:
+    def __init__(self, *, cache):
+        pass
+
+    def new_archive(self, *, archive):
+        pass
+
+    def upgrade_item(self, *, item):
+        return item
+
+    def upgrade_compressed_chunk(self, *, chunk):
+        return chunk
+
+    def upgrade_archive_metadata(self, *, metadata):
+        new_metadata = {}
+        # keep all metadata except archive version and stats.
+        for attr in ('cmdline', 'hostname', 'username', 'time', 'time_end', 'comment',
+                     'chunker_params', 'recreate_cmdline'):
+            if hasattr(metadata, attr):
+                new_metadata[attr] = getattr(metadata, attr)
+        return new_metadata
+
+
+class UpgraderFrom12To20:
+    def __init__(self, *, cache):
+        self.cache = cache
+
+    def new_archive(self, *, archive):
+        self.archive = archive
+        self.hlm = HardLinkManager(id_type=bytes, info_type=tuple)  # hlid -> (chunks, chunks_healthy)
+
+    def upgrade_item(self, *, item):
+        """upgrade item as needed, get rid of legacy crap"""
+        ITEM_KEY_WHITELIST = {'path', 'source', 'rdev', 'chunks', 'chunks_healthy', 'hlid',
+                              'mode', 'user', 'group', 'uid', 'gid', 'mtime', 'atime', 'ctime', 'birthtime', 'size',
+                              'xattrs', 'bsdflags', 'acl_nfs4', 'acl_access', 'acl_default', 'acl_extended',
+                              'part'}
+
+        if self.hlm.borg1_hardlink_master(item):
+            item._dict['hlid'] = hlid = self.hlm.hardlink_id_from_path(item._dict['path'])
+            self.hlm.remember(id=hlid, info=(item._dict.get('chunks'), item._dict.get('chunks_healthy')))
+        elif self.hlm.borg1_hardlink_slave(item):
+            item._dict['hlid'] = hlid = self.hlm.hardlink_id_from_path(item._dict['source'])
+            chunks, chunks_healthy = self.hlm.retrieve(id=hlid, default=(None, None))
+            if chunks is not None:
+                item._dict['chunks'] = chunks
+                for chunk_id, _ in chunks:
+                    self.cache.chunk_incref(chunk_id, self.archive.stats)
+            if chunks_healthy is not None:
+                item._dict['chunks_healthy'] = chunks
+            item._dict.pop('source')  # not used for hardlinks any more, replaced by hlid
+        # make sure we only have desired stuff in the new item. specifically, make sure to get rid of:
+        # - 'acl' remnants of bug in attic <= 0.13
+        # - 'hardlink_master' (superseded by hlid)
+        new_item_dict = {key: value for key, value in item.as_dict().items() if key in ITEM_KEY_WHITELIST}
+        new_item = Item(internal_dict=new_item_dict)
+        new_item.get_size(memorize=True)  # if not already present: compute+remember size for items with chunks
+        assert all(key in new_item for key in REQUIRED_ITEM_KEYS)
+        return new_item
+
+    def upgrade_compressed_chunk(self, *, chunk):
+        def upgrade_zlib_and_level(chunk):
+            if ZLIB_legacy.detect(chunk):
+                ctype = ZLIB.ID
+                chunk = ctype + level + chunk  # get rid of the attic legacy: prepend separate type/level bytes
+            else:
+                ctype = chunk[0:1]
+                chunk = ctype + level + chunk[2:]  # keep type same, but set level
+            return chunk
+
+        ctype = chunk[0:1]
+        level = b'\xFF'  # FF means unknown compression level
+
+        if ctype == ObfuscateSize.ID:
+            # in older borg, we used unusual byte order
+            old_header_fmt = Struct('>I')
+            new_header_fmt = ObfuscateSize.header_fmt
+            length = ObfuscateSize.header_len
+            size_bytes = chunk[2:2+length]
+            size = old_header_fmt.unpack(size_bytes)
+            size_bytes = new_header_fmt.pack(size)
+            compressed = chunk[2+length:]
+            compressed = upgrade_zlib_and_level(compressed)
+            chunk = ctype + level + size_bytes + compressed
+        else:
+            chunk = upgrade_zlib_and_level(chunk)
+        return chunk
+
+    def upgrade_archive_metadata(self, *, metadata):
+        new_metadata = {}
+        # keep all metadata except archive version and stats. also do not keep
+        # recreate_source_id, recreate_args, recreate_partial_chunks which were used only in 1.1.0b1 .. b2.
+        for attr in ('cmdline', 'hostname', 'username', 'time', 'time_end', 'comment',
+                     'chunker_params', 'recreate_cmdline'):
+            if hasattr(metadata, attr):
+                new_metadata[attr] = getattr(metadata, attr)
+        return new_metadata

From f7ef674f2901ba374608cbc44287d2917e0f862f Mon Sep 17 00:00:00 2001
From: Thomas Waldmann <tw@waldmann-edv.de>
Date: Tue, 28 Jun 2022 15:22:58 +0200
Subject: [PATCH 087/160] fix memoryview/bytes issue in upgrader

---
 src/borg/upgrade.py | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/borg/upgrade.py b/src/borg/upgrade.py
index 2f88d791f..1dfef64ec 100644
--- a/src/borg/upgrade.py
+++ b/src/borg/upgrade.py
@@ -73,10 +73,10 @@ class UpgraderFrom12To20:
         def upgrade_zlib_and_level(chunk):
             if ZLIB_legacy.detect(chunk):
                 ctype = ZLIB.ID
-                chunk = ctype + level + chunk  # get rid of the attic legacy: prepend separate type/level bytes
+                chunk = ctype + level + bytes(chunk)  # get rid of the attic legacy: prepend separate type/level bytes
             else:
-                ctype = chunk[0:1]
-                chunk = ctype + level + chunk[2:]  # keep type same, but set level
+                ctype = bytes(chunk[0:1])
+                chunk = ctype + level + bytes(chunk[2:])  # keep type same, but set level
             return chunk
 
         ctype = chunk[0:1]

From 8ebdb0b024861f64764acbe89d784eb795022f61 Mon Sep 17 00:00:00 2001
From: Thomas Waldmann <tw@waldmann-edv.de>
Date: Wed, 29 Jun 2022 17:31:50 +0200
Subject: [PATCH 088/160] support repo version 1 also, fixes #6811

v2 is the default repo version for borg 2.0.
v1 repos must only be used in a read-only way, e.g. for
--other-repo=V1_REPO with borg init and borg transfer!
---
 src/borg/repository.py | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/src/borg/repository.py b/src/borg/repository.py
index 420dea516..d31d4a9d6 100644
--- a/src/borg/repository.py
+++ b/src/borg/repository.py
@@ -198,6 +198,10 @@ class Repository:
         self.transaction_doomed = None
         self.check_segment_magic = check_segment_magic
         self.make_parent_dirs = make_parent_dirs
+        # v2 is the default repo version for borg 2.0
+        # v1 repos must only be used in a read-only way, e.g. for
+        # --other-repo=V1_REPO with borg init and borg transfer!
+        self.acceptable_repo_versions = (1, 2, )
 
     def __del__(self):
         if self.lock:
@@ -460,7 +464,7 @@ class Repository:
             self.close()
             raise self.InvalidRepositoryConfig(path, 'no repository section found')
         self.version = self.config.getint('repository', 'version')
-        if self.version not in (2, ):  # for now, only work on new repos
+        if self.version not in self.acceptable_repo_versions:
             self.close()
             raise self.InvalidRepositoryConfig(
                 path,

From dc2f2f47a893dd4a4ac465a3ed5fdceab2e000a0 Mon Sep 17 00:00:00 2001
From: Thomas Waldmann <tw@waldmann-edv.de>
Date: Wed, 29 Jun 2022 22:51:23 +0200
Subject: [PATCH 089/160] rcreate: remove legacy encryption modes for new
 repos, fixes #6490

These are legacy crypto modes based on AES-CTR mode:
(repokey|keyfile)[-blake2]

New crypto modes with session keys and AEAD ciphers:

(repokey|keyfile)[-blake2]-(aes-ocb|chacha20-poly1305)

Tests needed some changes:
- most used repokey/keyfile, changed to new modes
- some nonce tests removed, the new crypto code does not generate
  the repo side nonces any more (were only used for AES-CTR)
---
 src/borg/archiver.py           |  40 +--
 src/borg/crypto/key.py         |  21 +-
 src/borg/testsuite/archiver.py | 461 ++++++++++++++-------------------
 3 files changed, 228 insertions(+), 294 deletions(-)

diff --git a/src/borg/archiver.py b/src/borg/archiver.py
index 8f7c4e449..1bb4c1487 100644
--- a/src/borg/archiver.py
+++ b/src/borg/archiver.py
@@ -48,6 +48,8 @@ try:
     from .compress import CompressionSpec, ZLIB, ZLIB_legacy, ObfuscateSize
     from .crypto.key import key_creator, key_argument_names, tam_required_file, tam_required
     from .crypto.key import RepoKey, KeyfileKey, Blake2RepoKey, Blake2KeyfileKey, FlexiKey
+    from .crypto.key import AESOCBRepoKey, CHPORepoKey, Blake2AESOCBRepoKey, Blake2CHPORepoKey
+    from .crypto.key import AESOCBKeyfileKey, CHPOKeyfileKey, Blake2AESOCBKeyfileKey, Blake2CHPOKeyfileKey
     from .crypto.keymanager import KeyManager
     from .helpers import EXIT_SUCCESS, EXIT_WARNING, EXIT_ERROR, EXIT_SIGNAL_BASE
     from .helpers import Error, NoManifestError, set_ec
@@ -503,28 +505,32 @@ class Archiver:
             return EXIT_ERROR
 
         if args.key_mode == 'keyfile':
-            if isinstance(key, RepoKey):
-                key_new = KeyfileKey(repository)
-            elif isinstance(key, Blake2RepoKey):
-                key_new = Blake2KeyfileKey(repository)
-            elif isinstance(key, (KeyfileKey, Blake2KeyfileKey)):
-                print(f"Location already is {args.key_mode}")
-                return EXIT_SUCCESS
+            if isinstance(key, AESOCBRepoKey):
+                key_new = AESOCBKeyfileKey(repository)
+            elif isinstance(key, CHPORepoKey):
+                key_new = CHPOKeyfileKey(repository)
+            elif isinstance(key, Blake2AESOCBRepoKey):
+                key_new = Blake2AESOCBKeyfileKey(repository)
+            elif isinstance(key, Blake2CHPORepoKey):
+                key_new = Blake2CHPOKeyfileKey(repository)
             else:
-                raise Error("Unsupported key type")
+                print("Change not needed or not supported.")
+                return EXIT_WARNING
         if args.key_mode == 'repokey':
-            if isinstance(key, KeyfileKey):
-                key_new = RepoKey(repository)
-            elif isinstance(key, Blake2KeyfileKey):
-                key_new = Blake2RepoKey(repository)
-            elif isinstance(key, (RepoKey, Blake2RepoKey)):
-                print(f"Location already is {args.key_mode}")
-                return EXIT_SUCCESS
+            if isinstance(key, AESOCBKeyfileKey):
+                key_new = AESOCBRepoKey(repository)
+            elif isinstance(key, CHPOKeyfileKey):
+                key_new = CHPORepoKey(repository)
+            elif isinstance(key, Blake2AESOCBKeyfileKey):
+                key_new = Blake2AESOCBRepoKey(repository)
+            elif isinstance(key, Blake2CHPOKeyfileKey):
+                key_new = Blake2CHPORepoKey(repository)
             else:
-                raise Error("Unsupported key type")
+                print("Change not needed or not supported.")
+                return EXIT_WARNING
 
         for name in ('repository_id', 'enc_key', 'enc_hmac_key', 'id_key', 'chunk_seed',
-                     'tam_required', 'nonce_manager', 'cipher'):
+                     'tam_required', 'sessionid', 'cipher'):
             value = getattr(key, name)
             setattr(key_new, name, value)
 
diff --git a/src/borg/crypto/key.py b/src/borg/crypto/key.py
index 7dfda5851..e1c58c47a 100644
--- a/src/borg/crypto/key.py
+++ b/src/borg/crypto/key.py
@@ -98,7 +98,7 @@ def identify_key(manifest_data):
     if key_type == KeyType.PASSPHRASE:  # legacy, see comment in KeyType class.
         return RepoKey
 
-    for key in AVAILABLE_KEY_TYPES:
+    for key in LEGACY_KEY_TYPES + AVAILABLE_KEY_TYPES:
         if key.TYPE == key_type:
             return key
     else:
@@ -977,7 +977,7 @@ class CHPORepoKey(ID_HMAC_SHA_256, AEADKeyBase, FlexiKey):
 class Blake2AESOCBKeyfileKey(ID_BLAKE2b_256, AEADKeyBase, FlexiKey):
     TYPES_ACCEPTABLE = {KeyType.BLAKE2AESOCBKEYFILE, KeyType.BLAKE2AESOCBREPO}
     TYPE = KeyType.BLAKE2AESOCBKEYFILE
-    NAME = 'key file Blake2b AES-OCB'
+    NAME = 'key file BLAKE2b AES-OCB'
     ARG_NAME = 'keyfile-blake2-aes-ocb'
     STORAGE = KeyBlobStorage.KEYFILE
     CIPHERSUITE = AES256_OCB
@@ -986,7 +986,7 @@ class Blake2AESOCBKeyfileKey(ID_BLAKE2b_256, AEADKeyBase, FlexiKey):
 class Blake2AESOCBRepoKey(ID_BLAKE2b_256, AEADKeyBase, FlexiKey):
     TYPES_ACCEPTABLE = {KeyType.BLAKE2AESOCBKEYFILE, KeyType.BLAKE2AESOCBREPO}
     TYPE = KeyType.BLAKE2AESOCBREPO
-    NAME = 'repokey Blake2b AES-OCB'
+    NAME = 'repokey BLAKE2b AES-OCB'
     ARG_NAME = 'repokey-blake2-aes-ocb'
     STORAGE = KeyBlobStorage.REPO
     CIPHERSUITE = AES256_OCB
@@ -995,7 +995,7 @@ class Blake2AESOCBRepoKey(ID_BLAKE2b_256, AEADKeyBase, FlexiKey):
 class Blake2CHPOKeyfileKey(ID_BLAKE2b_256, AEADKeyBase, FlexiKey):
     TYPES_ACCEPTABLE = {KeyType.BLAKE2CHPOKEYFILE, KeyType.BLAKE2CHPOREPO}
     TYPE = KeyType.BLAKE2CHPOKEYFILE
-    NAME = 'key file Blake2b ChaCha20-Poly1305'
+    NAME = 'key file BLAKE2b ChaCha20-Poly1305'
     ARG_NAME = 'keyfile-blake2-chacha20-poly1305'
     STORAGE = KeyBlobStorage.KEYFILE
     CIPHERSUITE = CHACHA20_POLY1305
@@ -1004,16 +1004,23 @@ class Blake2CHPOKeyfileKey(ID_BLAKE2b_256, AEADKeyBase, FlexiKey):
 class Blake2CHPORepoKey(ID_BLAKE2b_256, AEADKeyBase, FlexiKey):
     TYPES_ACCEPTABLE = {KeyType.BLAKE2CHPOKEYFILE, KeyType.BLAKE2CHPOREPO}
     TYPE = KeyType.BLAKE2CHPOREPO
-    NAME = 'repokey Blake2b ChaCha20-Poly1305'
+    NAME = 'repokey BLAKE2b ChaCha20-Poly1305'
     ARG_NAME = 'repokey-blake2-chacha20-poly1305'
     STORAGE = KeyBlobStorage.REPO
     CIPHERSUITE = CHACHA20_POLY1305
 
 
+LEGACY_KEY_TYPES = (
+    # legacy (AES-CTR based) crypto
+    KeyfileKey, RepoKey,
+    Blake2KeyfileKey, Blake2RepoKey,
+)
+
 AVAILABLE_KEY_TYPES = (
+    # these are available encryption modes for new repositories
+    # not encrypted modes
     PlaintextKey,
-    KeyfileKey, RepoKey, AuthenticatedKey,
-    Blake2KeyfileKey, Blake2RepoKey, Blake2AuthenticatedKey,
+    AuthenticatedKey, Blake2AuthenticatedKey,
     # new crypto
     AESOCBKeyfileKey, AESOCBRepoKey,
     CHPOKeyfileKey, CHPORepoKey,
diff --git a/src/borg/testsuite/archiver.py b/src/borg/testsuite/archiver.py
index f7b11206a..7c34da238 100644
--- a/src/borg/testsuite/archiver.py
+++ b/src/borg/testsuite/archiver.py
@@ -36,7 +36,7 @@ from ..cache import Cache, LocalCache
 from ..chunker import has_seek_hole
 from ..constants import *  # NOQA
 from ..crypto.low_level import bytes_to_long, num_cipher_blocks
-from ..crypto.key import FlexiKey, RepoKey, KeyfileKey, Passphrase, TAMRequiredError
+from ..crypto.key import FlexiKey, AESOCBRepoKey, AESOCBKeyfileKey, CHPOKeyfileKey, Passphrase, TAMRequiredError
 from ..crypto.keymanager import RepoIdMismatch, NotABorgKeyFile
 from ..crypto.file_integrity import FileIntegrityError
 from ..helpers import Location, get_security_dir
@@ -59,6 +59,8 @@ from . import are_symlinks_supported, are_hardlinks_supported, are_fifos_support
 from .platform import fakeroot_detected, is_darwin
 from . import key
 
+RK_ENCRYPTION = '--encryption=repokey-aes-ocb'
+KF_ENCRYPTION = '--encryption=keyfile-chacha20-poly1305'
 
 src_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), '..'))
 
@@ -391,7 +393,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
     def test_basic_functionality(self):
         have_root = self.create_test_files()
         # fork required to test show-rc output
-        output = self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey', '--show-version', '--show-rc', fork=True)
+        output = self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION, '--show-version', '--show-rc', fork=True)
         self.assert_in('borgbackup version', output)
         self.assert_in('terminating with success status, rc 0', output)
         self.cmd(f'--repo={self.repository_location}', 'create', '--exclude-nodump', 'test', 'input')
@@ -481,7 +483,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         assert os.path.exists(parent_path)
 
     def test_unix_socket(self):
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
         try:
             sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
             sock.bind(os.path.join(self.input_path, 'unix-socket'))
@@ -499,7 +501,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
     @pytest.mark.skipif(not are_symlinks_supported(), reason='symlinks not supported')
     def test_symlink_extract(self):
         self.create_test_files()
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
         self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
         with changedir('output'):
             self.cmd(f'--repo={self.repository_location}', 'extract', 'test')
@@ -512,7 +514,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         with changedir('input'):
             os.symlink('target', 'symlink1')
             os.link('symlink1', 'symlink2', follow_symlinks=False)
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
         self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
         with changedir('output'):
             output = self.cmd(f'--repo={self.repository_location}', 'extract', 'test')
@@ -546,7 +548,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         atime, mtime = 123456780, 234567890
         have_noatime = has_noatime('input/file1')
         os.utime('input/file1', (atime, mtime))
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
         self.cmd(f'--repo={self.repository_location}', 'create', '--atime', 'test', 'input')
         with changedir('output'):
             self.cmd(f'--repo={self.repository_location}', 'extract', 'test')
@@ -566,7 +568,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         birthtime, mtime, atime = 946598400, 946684800, 946771200
         os.utime('input/file1', (atime, birthtime))
         os.utime('input/file1', (atime, mtime))
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
         self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
         with changedir('output'):
             self.cmd(f'--repo={self.repository_location}', 'extract', 'test')
@@ -582,7 +584,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         birthtime, mtime, atime = 946598400, 946684800, 946771200
         os.utime('input/file1', (atime, birthtime))
         os.utime('input/file1', (atime, mtime))
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
         self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input', '--nobirthtime')
         with changedir('output'):
             self.cmd(f'--repo={self.repository_location}', 'extract', 'test')
@@ -643,7 +645,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         if sparse_support:
             # we could create a sparse input file, so creating a backup of it and
             # extracting it again (as sparse) should also work:
-            self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
+            self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
             self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
             with changedir(self.output_path):
                 self.cmd(f'--repo={self.repository_location}', 'extract', 'test', '--sparse')
@@ -662,7 +664,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
             filename = os.path.join(self.input_path, filename)
             with open(filename, 'wb'):
                 pass
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
         self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
         for filename in filenames:
             with changedir('output'):
@@ -672,7 +674,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
     def test_repository_swap_detection(self):
         self.create_test_files()
         os.environ['BORG_PASSPHRASE'] = 'passphrase'
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
         repository_id = self._extract_repository_id(self.repository_path)
         self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
         shutil.rmtree(self.repository_path)
@@ -689,7 +691,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self.create_test_files()
         self.cmd(f'--repo={self.repository_location}_unencrypted', 'rcreate', '--encryption=none')
         os.environ['BORG_PASSPHRASE'] = 'passphrase'
-        self.cmd(f'--repo={self.repository_location}_encrypted', 'rcreate', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}_encrypted', 'rcreate', RK_ENCRYPTION)
         self.cmd(f'--repo={self.repository_location}_encrypted', 'create', 'test', 'input')
         shutil.rmtree(self.repository_path + '_encrypted')
         os.rename(self.repository_path + '_unencrypted', self.repository_path + '_encrypted')
@@ -702,7 +704,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
     def test_repository_swap_detection_no_cache(self):
         self.create_test_files()
         os.environ['BORG_PASSPHRASE'] = 'passphrase'
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
         repository_id = self._extract_repository_id(self.repository_path)
         self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
         shutil.rmtree(self.repository_path)
@@ -720,7 +722,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self.create_test_files()
         self.cmd(f'--repo={self.repository_location}_unencrypted', 'rcreate', '--encryption=none')
         os.environ['BORG_PASSPHRASE'] = 'passphrase'
-        self.cmd(f'--repo={self.repository_location}_encrypted', 'rcreate', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}_encrypted', 'rcreate', RK_ENCRYPTION)
         self.cmd(f'--repo={self.repository_location}_encrypted', 'create', 'test', 'input')
         self.cmd(f'--repo={self.repository_location}_unencrypted', 'rdelete', '--cache-only')
         self.cmd(f'--repo={self.repository_location}_encrypted', 'rdelete', '--cache-only')
@@ -736,12 +738,12 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         # Check that a repokey repo with a blank passphrase is considered like a plaintext repo.
         self.create_test_files()
         # User initializes her repository with her passphrase
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
         self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
         # Attacker replaces it with her own repository, which is encrypted but has no passphrase set
         shutil.rmtree(self.repository_path)
         with environment_variable(BORG_PASSPHRASE=''):
-            self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
+            self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
             # Delete cache & security database, AKA switch to user perspective
             self.cmd(f'--repo={self.repository_location}', 'rdelete', '--cache-only')
             shutil.rmtree(self.get_security_dir())
@@ -756,7 +758,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
                     self.cmd(f'--repo={self.repository_location}', 'create', 'test.2', 'input')
 
     def test_repository_move(self):
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
         security_dir = self.get_security_dir()
         os.rename(self.repository_path, self.repository_path + '_new')
         with environment_variable(BORG_RELOCATED_REPO_ACCESS_IS_OK='yes'):
@@ -774,7 +776,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
             assert os.path.exists(os.path.join(security_dir, file))
 
     def test_security_dir_compat(self):
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
         with open(os.path.join(self.get_security_dir(), 'location'), 'w') as fd:
             fd.write('something outdated')
         # This is fine, because the cache still has the correct information. security_dir and cache can disagree
@@ -802,7 +804,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
             self.cmd(f'--repo={self.repository_location}', 'rinfo')
 
     def test_strip_components(self):
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
         self.create_regular_file('dir/file')
         self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
         with changedir('output'):
@@ -831,7 +833,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         os.link(os.path.join(self.input_path, 'dir1/source2'),
                 os.path.join(self.input_path, 'dir1/aaaa'))
 
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
         self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
 
     @requires_hardlinks
@@ -921,7 +923,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
             assert os.stat('input/b/hardlink').st_nlink == 2
 
     def test_extract_include_exclude(self):
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
         self.create_regular_file('file1', size=1024 * 80)
         self.create_regular_file('file2', size=1024 * 80)
         self.create_regular_file('file3', size=1024 * 80)
@@ -938,7 +940,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self.assert_equal(sorted(os.listdir('output/input')), ['file1', 'file3'])
 
     def test_extract_include_exclude_regex(self):
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
         self.create_regular_file('file1', size=1024 * 80)
         self.create_regular_file('file2', size=1024 * 80)
         self.create_regular_file('file3', size=1024 * 80)
@@ -971,7 +973,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self.assert_equal(sorted(os.listdir('output/input')), ['file3'])
 
     def test_extract_include_exclude_regex_from_file(self):
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
         self.create_regular_file('file1', size=1024 * 80)
         self.create_regular_file('file2', size=1024 * 80)
         self.create_regular_file('file3', size=1024 * 80)
@@ -1011,7 +1013,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self.assert_equal(sorted(os.listdir('output/input')), ['file3'])
 
     def test_extract_with_pattern(self):
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
         self.create_regular_file("file1", size=1024 * 80)
         self.create_regular_file("file2", size=1024 * 80)
         self.create_regular_file("file3", size=1024 * 80)
@@ -1044,7 +1046,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self.assert_equal(sorted(os.listdir("output/input")), ["file1", "file2", "file333"])
 
     def test_extract_list_output(self):
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
         self.create_regular_file('file', size=1024 * 80)
 
         self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
@@ -1069,7 +1071,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self.assert_in("input/file", output)
 
     def test_extract_progress(self):
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
         self.create_regular_file('file', size=1024 * 80)
         self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
 
@@ -1078,7 +1080,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
             assert 'Extracting:' in output
 
     def _create_test_caches(self):
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
         self.create_regular_file('file1', size=1024 * 80)
         self.create_regular_file('cache1/%s' % CACHE_TAG_NAME,
                                  contents=CACHE_TAG_CONTENTS + b' extra stuff')
@@ -1092,7 +1094,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
                                      contents=CACHE_TAG_CONTENTS + b' extra stuff')
 
     def test_create_stdin(self):
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
         input_data = b'\x00foo\n\nbar\n   \n'
         self.cmd(f'--repo={self.repository_location}', 'create', 'test', '-', input=input_data)
         item = json.loads(self.cmd(f'--repo={self.repository_location}', 'list', 'test', '--json-lines'))
@@ -1104,7 +1106,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         assert extracted_data == input_data
 
     def test_create_content_from_command(self):
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
         input_data = 'some test content'
         name = 'a/b/c'
         self.cmd(f'--repo={self.repository_location}', 'create', '--stdin-name', name, '--content-from-command',
@@ -1118,7 +1120,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         assert extracted_data == input_data + '\n'
 
     def test_create_content_from_command_with_failed_command(self):
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
         output = self.cmd(f'--repo={self.repository_location}', 'create', '--content-from-command', 'test',
                           '--', 'sh', '-c', 'exit 73;', exit_code=2)
         assert output.endswith("Command 'sh' exited with status 73\n")
@@ -1126,12 +1128,12 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         assert archive_list['archives'] == []
 
     def test_create_content_from_command_missing_command(self):
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
         output = self.cmd(f'--repo={self.repository_location}', 'create', 'test', '--content-from-command', exit_code=2)
         assert output.endswith('No command given.\n')
 
     def test_create_paths_from_stdin(self):
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
         self.create_regular_file("file1", size=1024 * 80)
         self.create_regular_file("dir1/file2", size=1024 * 80)
         self.create_regular_file("dir1/file3", size=1024 * 80)
@@ -1145,7 +1147,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         assert paths == ['input/file1', 'input/dir1', 'input/file4']
 
     def test_create_paths_from_command(self):
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
         self.create_regular_file("file1", size=1024 * 80)
         self.create_regular_file("file2", size=1024 * 80)
         self.create_regular_file("file3", size=1024 * 80)
@@ -1159,7 +1161,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         assert paths == ['input/file1', 'input/file2', 'input/file3']
 
     def test_create_paths_from_command_with_failed_command(self):
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
         output = self.cmd(f'--repo={self.repository_location}', 'create', '--paths-from-command', 'test',
                           '--', 'sh', '-c', 'exit 73;', exit_code=2)
         assert output.endswith("Command 'sh' exited with status 73\n")
@@ -1167,18 +1169,18 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         assert archive_list['archives'] == []
 
     def test_create_paths_from_command_missing_command(self):
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
         output = self.cmd(f'--repo={self.repository_location}', 'create', 'test', '--paths-from-command', exit_code=2)
         assert output.endswith('No command given.\n')
 
     def test_create_without_root(self):
         """test create without a root"""
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
         self.cmd(f'--repo={self.repository_location}', 'create', 'test', exit_code=2)
 
     def test_create_pattern_root(self):
         """test create with only a root pattern"""
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
         self.create_regular_file('file1', size=1024 * 80)
         self.create_regular_file('file2', size=1024 * 80)
         output = self.cmd(f'--repo={self.repository_location}', 'create', 'test', '-v', '--list', '--pattern=R input')
@@ -1187,7 +1189,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
 
     def test_create_pattern(self):
         """test file patterns during create"""
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
         self.create_regular_file('file1', size=1024 * 80)
         self.create_regular_file('file2', size=1024 * 80)
         self.create_regular_file('file_important', size=1024 * 80)
@@ -1200,7 +1202,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
 
     def test_create_pattern_file(self):
         """test file patterns during create"""
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
         self.create_regular_file('file1', size=1024 * 80)
         self.create_regular_file('file2', size=1024 * 80)
         self.create_regular_file('otherfile', size=1024 * 80)
@@ -1219,7 +1221,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         with open(self.patterns_file_path2, 'wb') as fd:
             fd.write(b'+ input/x/b\n- input/x*\n')
 
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
         self.create_regular_file('x/a/foo_a', size=1024 * 80)
         self.create_regular_file('x/b/foo_b', size=1024 * 80)
         self.create_regular_file('y/foo_y', size=1024 * 80)
@@ -1236,7 +1238,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         with open(self.patterns_file_path2, 'wb') as fd:
             fd.write(b'+ input/x/b\n! input/x*\n')
 
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
         self.create_regular_file('x/a/foo_a', size=1024 * 80)
         self.create_regular_file('x/b/foo_b', size=1024 * 80)
         self.create_regular_file('y/foo_y', size=1024 * 80)
@@ -1253,7 +1255,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         with open(self.patterns_file_path2, 'wb') as fd:
             fd.write(b'+ input/x/a\n+ input/x/b\n- input/x*\n')
 
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
 
         self.create_regular_file('x/a/foo_a', size=1024 * 80)
         self.create_regular_file('x/b/foo_b', size=1024 * 80)
@@ -1274,7 +1276,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
 
     def test_create_no_cache_sync(self):
         self.create_test_files()
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
         self.cmd(f'--repo={self.repository_location}', 'rdelete', '--cache-only')
         create_json = json.loads(self.cmd(f'--repo={self.repository_location}', 'create',
                                           '--no-cache-sync', '--json', '--error',
@@ -1289,7 +1291,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self.cmd(f'--repo={self.repository_location}', 'check')
 
     def test_extract_pattern_opt(self):
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
         self.create_regular_file('file1', size=1024 * 80)
         self.create_regular_file('file2', size=1024 * 80)
         self.create_regular_file('file_important', size=1024 * 80)
@@ -1317,7 +1319,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self._assert_test_caches()
 
     def _create_test_tagged(self):
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
         self.create_regular_file('file1', size=1024 * 80)
         self.create_regular_file('tagged1/.NOBACKUP')
         self.create_regular_file('tagged2/00-NOBACKUP')
@@ -1342,7 +1344,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self._assert_test_tagged()
 
     def _create_test_keep_tagged(self):
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
         self.create_regular_file('file0', size=1024)
         self.create_regular_file('tagged1/.NOBACKUP1')
         self.create_regular_file('tagged1/file1', size=1024)
@@ -1408,7 +1410,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         capabilities = b'\x01\x00\x00\x02\x00 \x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
         self.create_regular_file('file')
         xattr.setxattr(b'input/file', b'security.capability', capabilities)
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
         self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
         with changedir('output'):
             with patch.object(os, 'fchown', patched_fchown):
@@ -1447,7 +1449,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
             assert os.path.isfile(input_abspath)
 
     def test_path_normalization(self):
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
         self.create_regular_file('dir1/dir2/file', size=1024 * 80)
         with changedir('input/dir1/dir2'):
             self.cmd(f'--repo={self.repository_location}', 'create', 'test',
@@ -1457,7 +1459,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self.assert_in(' input/dir1/dir2/file', output)
 
     def test_exclude_normalization(self):
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
         self.create_regular_file('file1', size=1024 * 80)
         self.create_regular_file('file2', size=1024 * 80)
         with changedir('input'):
@@ -1477,13 +1479,13 @@ class ArchiverTestCase(ArchiverTestCaseBase):
 
     def test_repeated_files(self):
         self.create_regular_file('file1', size=1024 * 80)
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
         self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input', 'input')
 
     def test_overwrite(self):
         self.create_regular_file('file1', size=1024 * 80)
         self.create_regular_file('dir2/file2', size=1024 * 80)
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
         self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
         # Overwriting regular files and directories should be supported
         os.mkdir('output/input')
@@ -1502,7 +1504,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
     def test_rename(self):
         self.create_regular_file('file1', size=1024 * 80)
         self.create_regular_file('dir2/file2', size=1024 * 80)
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
         self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
         self.cmd(f'--repo={self.repository_location}', 'create', 'test.2', 'input')
         self.cmd(f'--repo={self.repository_location}', 'extract', 'test', '--dry-run')
@@ -1521,7 +1523,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
 
     def test_info(self):
         self.create_regular_file('file1', size=1024 * 80)
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
         self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
         info_repo = self.cmd(f'--repo={self.repository_location}', 'rinfo')
         assert 'Original size:' in info_repo
@@ -1532,14 +1534,14 @@ class ArchiverTestCase(ArchiverTestCaseBase):
 
     def test_info_json(self):
         self.create_regular_file('file1', size=1024 * 80)
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
         self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
         info_repo = json.loads(self.cmd(f'--repo={self.repository_location}', 'rinfo', '--json'))
         repository = info_repo['repository']
         assert len(repository['id']) == 64
         assert 'last_modified' in repository
         assert datetime.strptime(repository['last_modified'], ISO_FORMAT)  # must not raise
-        assert info_repo['encryption']['mode'] == 'repokey'
+        assert info_repo['encryption']['mode'] == RK_ENCRYPTION[13:]
         assert 'keyfile' not in info_repo['encryption']
         cache = info_repo['cache']
         stats = cache['stats']
@@ -1562,7 +1564,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
 
     def test_info_json_of_empty_archive(self):
         """See https://github.com/borgbackup/borg/issues/6120"""
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
         info_repo = json.loads(self.cmd(f'--repo={self.repository_location}', 'info', '--json', '--first=1'))
         assert info_repo["archives"] == []
         info_repo = json.loads(self.cmd(f'--repo={self.repository_location}', 'info', '--json', '--last=1'))
@@ -1570,7 +1572,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
 
     def test_comment(self):
         self.create_regular_file('file1', size=1024 * 80)
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
         self.cmd(f'--repo={self.repository_location}', 'create', 'test1', 'input')
         self.cmd(f'--repo={self.repository_location}', 'create', 'test2', 'input', '--comment', 'this is the comment')
         self.cmd(f'--repo={self.repository_location}', 'create', 'test3', 'input', '--comment', '"deleted" comment')
@@ -1590,7 +1592,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
     def test_delete(self):
         self.create_regular_file('file1', size=1024 * 80)
         self.create_regular_file('dir2/file2', size=1024 * 80)
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
         self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
         self.cmd(f'--repo={self.repository_location}', 'create', 'test.2', 'input')
         self.cmd(f'--repo={self.repository_location}', 'create', 'test.3', 'input')
@@ -1610,7 +1612,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
 
     def test_delete_multiple(self):
         self.create_regular_file('file1', size=1024 * 80)
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
         self.cmd(f'--repo={self.repository_location}', 'create', 'test1', 'input')
         self.cmd(f'--repo={self.repository_location}', 'create', 'test2', 'input')
         self.cmd(f'--repo={self.repository_location}', 'create', 'test3', 'input')
@@ -1623,7 +1625,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
     def test_delete_repo(self):
         self.create_regular_file('file1', size=1024 * 80)
         self.create_regular_file('dir2/file2', size=1024 * 80)
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
         self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
         self.cmd(f'--repo={self.repository_location}', 'create', 'test.2', 'input')
         os.environ['BORG_DELETE_I_KNOW_WHAT_I_AM_DOING'] = 'no'
@@ -1668,7 +1670,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self.assert_not_in('test', output)
 
     def test_corrupted_repository(self):
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
         self.create_src_archive('test')
         self.cmd(f'--repo={self.repository_location}', 'extract', 'test', '--dry-run')
         output = self.cmd(f'--repo={self.repository_location}', 'check', '--show-version')
@@ -1683,7 +1685,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self.assert_in('Starting repository check', output)  # --info given for root logger
 
     def test_readonly_check(self):
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
         self.create_src_archive('test')
         with self.read_only(self.repository_path):
             # verify that command normally doesn't work with read-only repo
@@ -1698,7 +1700,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
             self.cmd(f'--repo={self.repository_location}', 'check', '--verify-data', '--bypass-lock')
 
     def test_readonly_diff(self):
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
         self.create_src_archive('a')
         self.create_src_archive('b')
         with self.read_only(self.repository_path):
@@ -1714,7 +1716,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
             self.cmd(f'--repo={self.repository_location}', 'diff', 'a', 'b', '--bypass-lock')
 
     def test_readonly_export_tar(self):
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
         self.create_src_archive('test')
         with self.read_only(self.repository_path):
             # verify that command normally doesn't work with read-only repo
@@ -1729,7 +1731,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
             self.cmd(f'--repo={self.repository_location}', 'export-tar', 'test', 'test.tar', '--bypass-lock')
 
     def test_readonly_extract(self):
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
         self.create_src_archive('test')
         with self.read_only(self.repository_path):
             # verify that command normally doesn't work with read-only repo
@@ -1744,7 +1746,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
             self.cmd(f'--repo={self.repository_location}', 'extract', 'test', '--bypass-lock')
 
     def test_readonly_info(self):
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
         self.create_src_archive('test')
         with self.read_only(self.repository_path):
             # verify that command normally doesn't work with read-only repo
@@ -1759,7 +1761,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
             self.cmd(f'--repo={self.repository_location}', 'rinfo', '--bypass-lock')
 
     def test_readonly_list(self):
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
         self.create_src_archive('test')
         with self.read_only(self.repository_path):
             # verify that command normally doesn't work with read-only repo
@@ -1775,7 +1777,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
 
     @unittest.skipUnless(llfuse, 'llfuse not installed')
     def test_readonly_mount(self):
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
         self.create_src_archive('test')
         with self.read_only(self.repository_path):
             # verify that command normally doesn't work with read-only repo
@@ -1796,13 +1798,13 @@ class ArchiverTestCase(ArchiverTestCaseBase):
     @pytest.mark.skipif('BORG_TESTS_IGNORE_MODES' in os.environ, reason='modes unreliable')
     def test_umask(self):
         self.create_regular_file('file1', size=1024 * 80)
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
         self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
         mode = os.stat(self.repository_path).st_mode
         self.assertEqual(stat.S_IMODE(mode), 0o700)
 
     def test_create_dry_run(self):
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
         self.cmd(f'--repo={self.repository_location}', 'create', '--dry-run', 'test', 'input')
         # Make sure no archive has been created
         with Repository(self.repository_path) as repository:
@@ -1825,23 +1827,23 @@ class ArchiverTestCase(ArchiverTestCaseBase):
             assert excinfo.value.args == (['unknown-feature'],)
 
     def test_unknown_feature_on_create(self):
-        print(self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey'))
+        print(self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION))
         self.add_unknown_feature(Manifest.Operation.WRITE)
         self.cmd_raises_unknown_feature([f'--repo={self.repository_location}', 'create', 'test', 'input'])
 
     def test_unknown_feature_on_cache_sync(self):
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
         self.cmd(f'--repo={self.repository_location}', 'rdelete', '--cache-only')
         self.add_unknown_feature(Manifest.Operation.READ)
         self.cmd_raises_unknown_feature([f'--repo={self.repository_location}', 'create', 'test', 'input'])
 
     def test_unknown_feature_on_change_passphrase(self):
-        print(self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey'))
+        print(self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION))
         self.add_unknown_feature(Manifest.Operation.CHECK)
         self.cmd_raises_unknown_feature([f'--repo={self.repository_location}', 'key', 'change-passphrase'])
 
     def test_unknown_feature_on_read(self):
-        print(self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey'))
+        print(self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION))
         self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
         self.add_unknown_feature(Manifest.Operation.READ)
         with changedir('output'):
@@ -1851,13 +1853,13 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self.cmd_raises_unknown_feature([f'--repo={self.repository_location}', 'info', '-a', 'test'])
 
     def test_unknown_feature_on_rename(self):
-        print(self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey'))
+        print(self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION))
         self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
         self.add_unknown_feature(Manifest.Operation.CHECK)
         self.cmd_raises_unknown_feature([f'--repo={self.repository_location}', 'rename', 'test', 'other'])
 
     def test_unknown_feature_on_delete(self):
-        print(self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey'))
+        print(self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION))
         self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
         self.add_unknown_feature(Manifest.Operation.DELETE)
         # delete of an archive raises
@@ -1868,7 +1870,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
 
     @unittest.skipUnless(llfuse, 'llfuse not installed')
     def test_unknown_feature_on_mount(self):
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
         self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
         self.add_unknown_feature(Manifest.Operation.READ)
         mountpoint = os.path.join(self.tmpdir, 'mountpoint')
@@ -1883,7 +1885,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         else:
             path_prefix = ''
 
-        print(self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey'))
+        print(self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION))
 
         with Repository(self.repository_path, exclusive=True) as repository:
             if path_prefix:
@@ -1919,13 +1921,13 @@ class ArchiverTestCase(ArchiverTestCaseBase):
 
     def test_progress_on(self):
         self.create_regular_file('file1', size=1024 * 80)
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
         output = self.cmd(f'--repo={self.repository_location}', 'create', 'test4', 'input', '--progress')
         self.assert_in("\r", output)
 
     def test_progress_off(self):
         self.create_regular_file('file1', size=1024 * 80)
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
         output = self.cmd(f'--repo={self.repository_location}', 'create', 'test5', 'input')
         self.assert_not_in("\r", output)
 
@@ -1936,7 +1938,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self.create_regular_file('file1', size=1024 * 80)
         time.sleep(1)  # file2 must have newer timestamps than file1
         self.create_regular_file('file2', size=1024 * 80)
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
         output = self.cmd(f'--repo={self.repository_location}', 'create', '--list', 'test', 'input')
         self.assert_in("A input/file1", output)
         self.assert_in("A input/file2", output)
@@ -1952,7 +1954,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self.create_regular_file('file1', contents=b'123')
         time.sleep(1)  # file2 must have newer timestamps than file1
         self.create_regular_file('file2', size=10)
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
         output = self.cmd(f'--repo={self.repository_location}', 'create', 'test1', 'input',
                           '--list', '--files-cache=ctime,size')
         # modify file1, but cheat with the mtime (and atime) and also keep same size:
@@ -1969,7 +1971,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self.create_regular_file('file1', size=10)
         time.sleep(1)  # file2 must have newer timestamps than file1
         self.create_regular_file('file2', size=10)
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
         output = self.cmd(f'--repo={self.repository_location}', 'create',
                           '--list', '--files-cache=mtime,size', 'test1', 'input')
         # change mode of file1, no content change:
@@ -1985,7 +1987,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self.create_regular_file('file1', size=10)
         time.sleep(1)  # file2 must have newer timestamps than file1
         self.create_regular_file('file2', size=10)
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
         output = self.cmd(f'--repo={self.repository_location}', 'create',
                           '--list', '--files-cache=rechunk,ctime', 'test1', 'input')
         # no changes here, but this mode rechunks unconditionally
@@ -2002,7 +2004,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         if has_lchflags:
             self.create_regular_file('file3', size=1024 * 80)
             platform.set_flags(os.path.join(self.input_path, 'file3'), stat.UF_NODUMP)
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
         output = self.cmd(f'--repo={self.repository_location}', 'create', '--list', '--exclude-nodump', 'test', 'input')
         self.assert_in("A input/file1", output)
         self.assert_in("A input/file2", output)
@@ -2018,7 +2020,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
 
     def test_create_json(self):
         self.create_regular_file('file1', size=1024 * 80)
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
         create_info = json.loads(self.cmd(f'--repo={self.repository_location}', 'create', '--json',
                                           'test', 'input'))
         # The usual keys
@@ -2038,7 +2040,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self.create_regular_file('file1', size=1024 * 80)
         time.sleep(1)  # file2 must have newer timestamps than file1
         self.create_regular_file('file2', size=1024 * 80)
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
         # no listing by default
         output = self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
         self.assert_not_in('file1', output)
@@ -2068,7 +2070,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
             finally:
                 os.close(fd)
 
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
         data = b'foobar' * 1000
 
         fifo_fn = os.path.join(self.input_path, 'fifo')
@@ -2091,20 +2093,20 @@ class ArchiverTestCase(ArchiverTestCaseBase):
 
     def test_create_read_special_broken_symlink(self):
         os.symlink('somewhere does not exist', os.path.join(self.input_path, 'link'))
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
         self.cmd(f'--repo={self.repository_location}', 'create', '--read-special', 'test', 'input')
         output = self.cmd(f'--repo={self.repository_location}', 'list', 'test')
         assert 'input/link -> somewhere does not exist' in output
 
     # def test_cmdline_compatibility(self):
     #    self.create_regular_file('file1', size=1024 * 80)
-    #    self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
+    #    self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
     #    self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
     #    output = self.cmd('foo', self.repository_location, '--old')
     #    self.assert_in('"--old" has been deprecated. Use "--new" instead', output)
 
     def test_prune_repository(self):
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
         self.cmd(f'--repo={self.repository_location}', 'create', 'test1', src_dir)
         self.cmd(f'--repo={self.repository_location}', 'create', 'test2', src_dir)
         # these are not really a checkpoints, but they look like some:
@@ -2153,7 +2155,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
 
     # This test must match docs/misc/prune-example.txt
     def test_prune_repository_example(self):
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
         # Archives that will be kept, per the example
         # Oldest archive
         self._create_archive_ts('test01', 2015, 1, 1)
@@ -2214,7 +2216,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
 
     # With an initial and daily backup, prune daily until oldest is replaced by a monthly backup
     def test_prune_retain_and_expire_oldest(self):
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
         # Initial backup
         self._create_archive_ts('original_archive', 2020, 9, 1, 11, 15)
         # Archive and prune daily for 30 days
@@ -2237,7 +2239,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self.assert_not_in('original_archive', output)
 
     def test_prune_repository_save_space(self):
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
         self.cmd(f'--repo={self.repository_location}', 'create', 'test1', src_dir)
         self.cmd(f'--repo={self.repository_location}', 'create', 'test2', src_dir)
         output = self.cmd(f'--repo={self.repository_location}', 'prune', '--list', '--dry-run', '--keep-daily=1')
@@ -2252,7 +2254,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self.assert_in('test2', output)
 
     def test_prune_repository_prefix(self):
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
         self.cmd(f'--repo={self.repository_location}', 'create', 'foo-2015-08-12-10:00', src_dir)
         self.cmd(f'--repo={self.repository_location}', 'create', 'foo-2015-08-12-20:00', src_dir)
         self.cmd(f'--repo={self.repository_location}', 'create', 'bar-2015-08-12-10:00', src_dir)
@@ -2273,7 +2275,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self.assert_in('bar-2015-08-12-20:00', output)
 
     def test_prune_repository_glob(self):
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
         self.cmd(f'--repo={self.repository_location}', 'create', '2015-08-12-10:00-foo', src_dir)
         self.cmd(f'--repo={self.repository_location}', 'create', '2015-08-12-20:00-foo', src_dir)
         self.cmd(f'--repo={self.repository_location}', 'create', '2015-08-12-10:00-bar', src_dir)
@@ -2294,7 +2296,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self.assert_in('2015-08-12-20:00-bar', output)
 
     def test_list_prefix(self):
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
         self.cmd(f'--repo={self.repository_location}', 'create', 'test-1', src_dir)
         self.cmd(f'--repo={self.repository_location}', 'create', 'something-else-than-test-1', src_dir)
         self.cmd(f'--repo={self.repository_location}', 'create', 'test-2', src_dir)
@@ -2304,7 +2306,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self.assert_not_in('something-else', output)
 
     def test_list_format(self):
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
         self.cmd(f'--repo={self.repository_location}', 'create', 'test', src_dir)
         output_1 = self.cmd(f'--repo={self.repository_location}', 'list', 'test')
         output_2 = self.cmd(f'--repo={self.repository_location}', 'list', 'test', '--format', '{mode} {user:6} {group:6} {size:8d} {mtime} {path}{extra}{NEWLINE}')
@@ -2313,7 +2315,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self.assertNotEqual(output_1, output_3)
 
     def test_archives_format(self):
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
         self.cmd(f'--repo={self.repository_location}', 'create', '--comment', 'comment 1', 'test-1', src_dir)
         self.cmd(f'--repo={self.repository_location}', 'create', '--comment', 'comment 2', 'test-2', src_dir)
         output_1 = self.cmd(f'--repo={self.repository_location}', 'rlist')
@@ -2330,14 +2332,14 @@ class ArchiverTestCase(ArchiverTestCaseBase):
     def test_list_hash(self):
         self.create_regular_file('empty_file', size=0)
         self.create_regular_file('amb', contents=b'a' * 1000000)
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
         self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
         output = self.cmd(f'--repo={self.repository_location}', 'list', 'test', '--format', '{sha256} {path}{NL}')
         assert "cdc76e5c9914fb9281a1c7e284d73e67f1809a48a497200e046d39ccc7112cd0 input/amb" in output
         assert "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855 input/empty_file" in output
 
     def test_list_consider_checkpoints(self):
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
         self.cmd(f'--repo={self.repository_location}', 'create', 'test1', src_dir)
         # these are not really a checkpoints, but they look like some:
         self.cmd(f'--repo={self.repository_location}', 'create', 'test2.checkpoint', src_dir)
@@ -2357,7 +2359,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         with open(os.path.join(self.input_path, 'two_chunks'), 'wb') as fd:
             fd.write(b'abba' * 2000000)
             fd.write(b'baab' * 2000000)
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
         self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
         output = self.cmd(f'--repo={self.repository_location}', 'list', 'test', '--format', '{num_chunks} {unique_chunks} {path}{NL}')
         assert "0 0 input/empty_file" in output
@@ -2365,7 +2367,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
 
     def test_list_size(self):
         self.create_regular_file('compressible_file', size=10000)
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
         self.cmd(f'--repo={self.repository_location}', 'create', '-C', 'lz4', 'test', 'input')
         output = self.cmd(f'--repo={self.repository_location}', 'list', 'test', '--format', '{size} {path}{NL}')
         size, path = output.split("\n")[1].split(" ")
@@ -2373,13 +2375,13 @@ class ArchiverTestCase(ArchiverTestCaseBase):
 
     def test_list_json(self):
         self.create_regular_file('file1', size=1024 * 80)
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
         self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
         list_repo = json.loads(self.cmd(f'--repo={self.repository_location}', 'rlist', '--json'))
         repository = list_repo['repository']
         assert len(repository['id']) == 64
         assert datetime.strptime(repository['last_modified'], ISO_FORMAT)  # must not raise
-        assert list_repo['encryption']['mode'] == 'repokey'
+        assert list_repo['encryption']['mode'] == RK_ENCRYPTION[13:]
         assert 'keyfile' not in list_repo['encryption']
         archive0 = list_repo['archives'][0]
         assert datetime.strptime(archive0['time'], ISO_FORMAT)  # must not raise
@@ -2401,7 +2403,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
 
     def test_log_json(self):
         self.create_test_files()
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
         log = self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input', '--log-json', '--list', '--debug')
         messages = {}  # type -> message, one of each kind
         for line in log.splitlines():
@@ -2419,7 +2421,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
 
     def test_debug_profile(self):
         self.create_test_files()
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
         self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input', '--debug-profile=create.prof')
         self.cmd('debug', 'convert-profile', 'create.prof', 'create.pyprof')
         stats = pstats.Stats('create.pyprof')
@@ -2433,12 +2435,12 @@ class ArchiverTestCase(ArchiverTestCaseBase):
 
     def test_common_options(self):
         self.create_test_files()
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
         log = self.cmd(f'--repo={self.repository_location}', '--debug', 'create', 'test', 'input')
         assert 'security: read previous location' in log
 
     def test_change_passphrase(self):
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
         os.environ['BORG_NEW_PASSPHRASE'] = 'newpassphrase'
         # here we have both BORG_PASSPHRASE and BORG_NEW_PASSPHRASE set:
         self.cmd(f'--repo={self.repository_location}', 'key', 'change-passphrase')
@@ -2446,39 +2448,39 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self.cmd(f'--repo={self.repository_location}', 'rlist')
 
     def test_change_location_to_keyfile(self):
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
         log = self.cmd(f'--repo={self.repository_location}', 'rinfo')
-        assert '(repokey)' in log
+        assert '(repokey' in log
         self.cmd(f'--repo={self.repository_location}', 'key', 'change-location', 'keyfile')
         log = self.cmd(f'--repo={self.repository_location}', 'rinfo')
-        assert '(key file)' in log
+        assert '(key file' in log
 
     def test_change_location_to_b2keyfile(self):
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey-blake2')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey-blake2-aes-ocb')
         log = self.cmd(f'--repo={self.repository_location}', 'rinfo')
-        assert '(repokey BLAKE2b)' in log
+        assert '(repokey BLAKE2b' in log
         self.cmd(f'--repo={self.repository_location}', 'key', 'change-location', 'keyfile')
         log = self.cmd(f'--repo={self.repository_location}', 'rinfo')
-        assert '(key file BLAKE2b)' in log
+        assert '(key file BLAKE2b' in log
 
     def test_change_location_to_repokey(self):
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=keyfile')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', KF_ENCRYPTION)
         log = self.cmd(f'--repo={self.repository_location}', 'rinfo')
-        assert '(key file)' in log
+        assert '(key file' in log
         self.cmd(f'--repo={self.repository_location}', 'key', 'change-location', 'repokey')
         log = self.cmd(f'--repo={self.repository_location}', 'rinfo')
-        assert '(repokey)' in log
+        assert '(repokey' in log
 
     def test_change_location_to_b2repokey(self):
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=keyfile-blake2')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=keyfile-blake2-aes-ocb')
         log = self.cmd(f'--repo={self.repository_location}', 'rinfo')
-        assert '(key file BLAKE2b)' in log
+        assert '(key file BLAKE2b' in log
         self.cmd(f'--repo={self.repository_location}', 'key', 'change-location', 'repokey')
         log = self.cmd(f'--repo={self.repository_location}', 'rinfo')
-        assert '(repokey BLAKE2b)' in log
+        assert '(repokey BLAKE2b' in log
 
     def test_break_lock(self):
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
         self.cmd(f'--repo={self.repository_location}', 'break-lock')
 
     def test_usage(self):
@@ -2505,7 +2507,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
                 noatime_used = flags_noatime != flags_normal
                 return noatime_used and atime_before == atime_after
 
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
         self.create_test_files()
         have_noatime = has_noatime('input/file1')
         self.cmd(f'--repo={self.repository_location}', 'create', '--exclude-nodump', '--atime', 'archive', 'input')
@@ -2594,7 +2596,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
 
     @unittest.skipUnless(llfuse, 'llfuse not installed')
     def test_fuse_versions_view(self):
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
         self.create_regular_file('test', contents=b'first')
         if are_hardlinks_supported():
             self.create_regular_file('hardlink1', contents=b'123456')
@@ -2626,7 +2628,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
 
     @unittest.skipUnless(llfuse, 'llfuse not installed')
     def test_fuse_allow_damaged_files(self):
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
         self.create_src_archive('archive')
         # Get rid of a chunk and repair it
         archive, repository = self.open_archive('archive')
@@ -2651,7 +2653,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
 
     @unittest.skipUnless(llfuse, 'llfuse not installed')
     def test_fuse_mount_options(self):
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
         self.create_src_archive('arch11')
         self.create_src_archive('arch12')
         self.create_src_archive('arch21')
@@ -2759,43 +2761,9 @@ class ArchiverTestCase(ArchiverTestCaseBase):
             # Undecorate
             borg.locking.Lock.migrate_lock = borg.locking.Lock.migrate_lock.__wrapped__
 
-    def verify_aes_counter_uniqueness(self, method):
-        seen = set()  # Chunks already seen
-        used = set()  # counter values already used
-
-        def verify_uniqueness():
-            with Repository(self.repository_path) as repository:
-                for id, _ in repository.open_index(repository.get_transaction_id()).iteritems():
-                    data = repository.get(id)
-                    hash = sha256(data).digest()
-                    if hash not in seen:
-                        seen.add(hash)
-                        num_blocks = num_cipher_blocks(len(data) - 41)
-                        nonce = bytes_to_long(data[33:41])
-                        for counter in range(nonce, nonce + num_blocks):
-                            self.assert_not_in(counter, used)
-                            used.add(counter)
-
-        self.create_test_files()
-        os.environ['BORG_PASSPHRASE'] = 'passphrase'
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=' + method)
-        verify_uniqueness()
-        self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
-        verify_uniqueness()
-        self.cmd(f'--repo={self.repository_location}', 'create', 'test.2', 'input')
-        verify_uniqueness()
-        self.cmd(f'--repo={self.repository_location}', 'delete', '-a', 'test.2')
-        verify_uniqueness()
-
-    def test_aes_counter_uniqueness_keyfile(self):
-        self.verify_aes_counter_uniqueness('keyfile')
-
-    def test_aes_counter_uniqueness_passphrase(self):
-        self.verify_aes_counter_uniqueness('repokey')
-
     def test_debug_dump_archive_items(self):
         self.create_test_files()
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
         self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
         with changedir('output'):
             output = self.cmd(f'--repo={self.repository_location}', 'debug', 'dump-archive-items', 'test')
@@ -2805,7 +2773,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
 
     def test_debug_dump_repo_objs(self):
         self.create_test_files()
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
         self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
         with changedir('output'):
             output = self.cmd(f'--repo={self.repository_location}', 'debug', 'dump-repo-objs')
@@ -2814,7 +2782,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         assert 'Done.' in output
 
     def test_debug_put_get_delete_obj(self):
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
         data = b'some data'
         hexkey = sha256(data).hexdigest()
         self.create_regular_file('file', contents=data)
@@ -2837,19 +2805,19 @@ class ArchiverTestCase(ArchiverTestCaseBase):
             raise EOFError
 
         with patch.object(FlexiKey, 'create', raise_eof):
-            self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey', exit_code=1)
+            self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION, exit_code=1)
         assert not os.path.exists(self.repository_location)
 
     def test_init_requires_encryption_option(self):
         self.cmd(f'--repo={self.repository_location}', 'rcreate', exit_code=2)
 
     def test_init_nested_repositories(self):
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
         if self.FORK_DEFAULT:
-            self.cmd(f'--repo={self.repository_location}/nested', 'rcreate', '--encryption=repokey', exit_code=2)
+            self.cmd(f'--repo={self.repository_location}/nested', 'rcreate', RK_ENCRYPTION, exit_code=2)
         else:
             with pytest.raises(Repository.AlreadyExists):
-                self.cmd(f'--repo={self.repository_location}/nested', 'rcreate', '--encryption=repokey')
+                self.cmd(f'--repo={self.repository_location}/nested', 'rcreate', RK_ENCRYPTION)
 
     def test_init_refuse_to_overwrite_keyfile(self):
         """BORG_KEY_FILE=something borg init should quit if "something" already exists.
@@ -2857,10 +2825,10 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         See https://github.com/borgbackup/borg/pull/6046"""
         keyfile = os.path.join(self.tmpdir, 'keyfile')
         with environment_variable(BORG_KEY_FILE=keyfile):
-            self.cmd(f'--repo={self.repository_location}0', 'rcreate', '--encryption=keyfile')
+            self.cmd(f'--repo={self.repository_location}0', 'rcreate', KF_ENCRYPTION)
             with open(keyfile) as file:
                 before = file.read()
-            arg = (f'--repo={self.repository_location}1', 'rcreate', '--encryption=keyfile')
+            arg = (f'--repo={self.repository_location}1', 'rcreate', KF_ENCRYPTION)
             if self.FORK_DEFAULT:
                 self.cmd(*arg, exit_code=2)
             else:
@@ -2892,7 +2860,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
             assert id in seen
 
     def test_check_cache(self):
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
         self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
         with self.open_repository() as repository:
             manifest, key = Manifest.load(repository, Manifest.NO_OPERATION_CHECK)
@@ -2904,13 +2872,13 @@ class ArchiverTestCase(ArchiverTestCaseBase):
             self.check_cache()
 
     def test_recreate_target_rc(self):
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
         output = self.cmd(f'--repo={self.repository_location}', 'recreate', '--target=asdf', exit_code=2)
         assert 'Need to specify single archive' in output
 
     def test_recreate_target(self):
         self.create_test_files()
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
         self.check_cache()
         self.cmd(f'--repo={self.repository_location}', 'create', 'test0', 'input')
         self.check_cache()
@@ -2930,7 +2898,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
     def test_recreate_basic(self):
         self.create_test_files()
         self.create_regular_file('dir2/file3', size=1024 * 80)
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
         self.cmd(f'--repo={self.repository_location}', 'create', 'test0', 'input')
         self.cmd(f'--repo={self.repository_location}', 'recreate', 'test0', 'input/dir2', '-e', 'input/dir2/file3')
         self.check_cache()
@@ -2960,7 +2928,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         with open(os.path.join(self.input_path, 'large_file'), 'wb') as fd:
             fd.write(b'a' * 280)
             fd.write(b'b' * 280)
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
         self.cmd(f'--repo={self.repository_location}', 'create', 'test1', 'input', '--chunker-params', '7,9,8,128')
         self.cmd(f'--repo={self.repository_location}', 'create', 'test2', 'input', '--files-cache=disabled')
         list = self.cmd(f'--repo={self.repository_location}', 'list', 'test1', 'input/large_file',
@@ -2977,7 +2945,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
 
     def test_recreate_recompress(self):
         self.create_regular_file('compressible', size=10000)
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
         self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input', '-C', 'none')
         file_list = self.cmd(f'--repo={self.repository_location}', 'list', 'test', 'input/compressible',
                              '--format', '{size} {sha256}')
@@ -2992,7 +2960,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
     def test_recreate_timestamp(self):
         local_timezone = datetime.now(timezone(timedelta(0))).astimezone().tzinfo
         self.create_test_files()
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
         self.cmd(f'--repo={self.repository_location}', 'create', 'test0', 'input')
         self.cmd(f'--repo={self.repository_location}', 'recreate', 'test0', '--timestamp', "1970-01-02T00:00:00",
                  '--comment', 'test')
@@ -3004,7 +2972,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
 
     def test_recreate_dry_run(self):
         self.create_regular_file('compressible', size=10000)
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
         self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
         archives_before = self.cmd(f'--repo={self.repository_location}', 'list', 'test')
         self.cmd(f'--repo={self.repository_location}', 'recreate', '-n', '-e', 'input/compressible')
@@ -3014,7 +2982,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
 
     def test_recreate_skips_nothing_to_do(self):
         self.create_regular_file('file1', size=1024 * 80)
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
         self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
         info_before = self.cmd(f'--repo={self.repository_location}', 'info', '-a', 'test')
         self.cmd(f'--repo={self.repository_location}', 'recreate', '--chunker-params', 'default')
@@ -3023,13 +2991,13 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         assert info_before == info_after  # includes archive ID
 
     def test_with_lock(self):
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
         lock_path = os.path.join(self.repository_path, 'lock.exclusive')
         cmd = 'python3', '-c', 'import os, sys; sys.exit(42 if os.path.exists("%s") else 23)' % lock_path
         self.cmd(f'--repo={self.repository_location}', 'with-lock', *cmd, fork=True, exit_code=42)
 
     def test_recreate_list_output(self):
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
         self.create_regular_file('file1', size=0)
         self.create_regular_file('file2', size=0)
         self.create_regular_file('file3', size=0)
@@ -3059,13 +3027,13 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self.assert_not_in("x input/file5", output)
 
     def test_bad_filters(self):
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
         self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
         self.cmd(f'--repo={self.repository_location}', 'delete', '--first', '1', '--last', '1', fork=True, exit_code=2)
 
     def test_key_export_keyfile(self):
         export_file = self.output_path + '/exported'
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption', 'keyfile')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', KF_ENCRYPTION)
         repo_id = self._extract_repository_id(self.repository_path)
         self.cmd(f'--repo={self.repository_location}', 'key', 'export', export_file)
 
@@ -3091,7 +3059,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         assert key_contents2 == key_contents
 
     def test_key_import_keyfile_with_borg_key_file(self):
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption', 'keyfile')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', KF_ENCRYPTION)
 
         exported_key_file = os.path.join(self.output_path, 'exported')
         self.cmd(f'--repo={self.repository_location}', 'key', 'export', exported_key_file)
@@ -3112,7 +3080,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
 
     def test_key_export_repokey(self):
         export_file = self.output_path + '/exported'
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption', 'repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
         repo_id = self._extract_repository_id(self.repository_path)
         self.cmd(f'--repo={self.repository_location}', 'key', 'export', export_file)
 
@@ -3122,10 +3090,10 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         assert export_contents.startswith('BORG_KEY ' + bin_to_hex(repo_id) + '\n')
 
         with Repository(self.repository_path) as repository:
-            repo_key = RepoKey(repository)
+            repo_key = AESOCBRepoKey(repository)
             repo_key.load(None, Passphrase.env_passphrase())
 
-        backup_key = KeyfileKey(key.TestKey.MockRepository())
+        backup_key = AESOCBKeyfileKey(key.TestKey.MockRepository())
         backup_key.load(export_file, Passphrase.env_passphrase())
 
         assert repo_key.enc_key == backup_key.enc_key
@@ -3136,14 +3104,14 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self.cmd(f'--repo={self.repository_location}', 'key', 'import', export_file)
 
         with Repository(self.repository_path) as repository:
-            repo_key2 = RepoKey(repository)
+            repo_key2 = AESOCBRepoKey(repository)
             repo_key2.load(None, Passphrase.env_passphrase())
 
         assert repo_key2.enc_key == repo_key2.enc_key
 
     def test_key_export_qr(self):
         export_file = self.output_path + '/exported.html'
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption', 'repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
         repo_id = self._extract_repository_id(self.repository_path)
         self.cmd(f'--repo={self.repository_location}', 'key', 'export', '--qr-html', export_file)
 
@@ -3158,13 +3126,13 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         export_directory = self.output_path + '/exported'
         os.mkdir(export_directory)
 
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption', 'repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
 
         self.cmd(f'--repo={self.repository_location}', 'key', 'export', export_directory, exit_code=EXIT_ERROR)
 
     def test_key_import_errors(self):
         export_file = self.output_path + '/exported'
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption', 'keyfile')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', KF_ENCRYPTION)
 
         self.cmd(f'--repo={self.repository_location}', 'key', 'import', export_file, exit_code=EXIT_ERROR)
 
@@ -3190,13 +3158,13 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         repo_id = 'e294423506da4e1ea76e8dcdf1a3919624ae3ae496fddf905610c351d3f09239'
 
         export_file = self.output_path + '/exported'
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption', 'keyfile')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', KF_ENCRYPTION)
         self._set_repository_id(self.repository_path, unhexlify(repo_id))
 
         key_file = self.keys_path + '/' + os.listdir(self.keys_path)[0]
 
         with open(key_file, 'w') as fd:
-            fd.write(KeyfileKey.FILE_ID + ' ' + repo_id + '\n')
+            fd.write(CHPOKeyfileKey.FILE_ID + ' ' + repo_id + '\n')
             fd.write(b2a_base64(b'abcdefghijklmnopqrstu').decode())
 
         self.cmd(f'--repo={self.repository_location}', 'key', 'export', '--paper', export_file)
@@ -3214,12 +3182,12 @@ id: 2 / e29442 3506da 4e1ea7 / 25f62a 5a3d41 - 02
 
     def test_key_import_paperkey(self):
         repo_id = 'e294423506da4e1ea76e8dcdf1a3919624ae3ae496fddf905610c351d3f09239'
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption', 'keyfile')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', KF_ENCRYPTION)
         self._set_repository_id(self.repository_path, unhexlify(repo_id))
 
         key_file = self.keys_path + '/' + os.listdir(self.keys_path)[0]
         with open(key_file, 'w') as fd:
-            fd.write(KeyfileKey.FILE_ID + ' ' + repo_id + '\n')
+            fd.write(AESOCBKeyfileKey.FILE_ID + ' ' + repo_id + '\n')
             fd.write(b2a_base64(b'abcdefghijklmnopqrstu').decode())
 
         typed_input = (
@@ -3259,7 +3227,7 @@ id: 2 / e29442 3506da 4e1ea7 / 25f62a 5a3d41 - 02
 
     def test_debug_dump_manifest(self):
         self.create_regular_file('file1', size=1024 * 80)
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
         self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
         dump_file = self.output_path + '/dump'
         output = self.cmd(f'--repo={self.repository_location}', 'debug', 'dump-manifest', dump_file)
@@ -3274,7 +3242,7 @@ id: 2 / e29442 3506da 4e1ea7 / 25f62a 5a3d41 - 02
 
     def test_debug_dump_archive(self):
         self.create_regular_file('file1', size=1024 * 80)
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
         self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
         dump_file = self.output_path + '/dump'
         output = self.cmd(f'--repo={self.repository_location}', 'debug', 'dump-archive', 'test', dump_file)
@@ -3287,7 +3255,7 @@ id: 2 / e29442 3506da 4e1ea7 / 25f62a 5a3d41 - 02
         assert '_items' in result
 
     def test_debug_refcount_obj(self):
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
         output = self.cmd(f'--repo={self.repository_location}', 'debug', 'refcount-obj', '0' * 64).strip()
         assert output == 'object 0000000000000000000000000000000000000000000000000000000000000000 not found [info from chunks cache].'
 
@@ -3306,14 +3274,14 @@ id: 2 / e29442 3506da 4e1ea7 / 25f62a 5a3d41 - 02
         assert 'Python' in output
 
     def test_benchmark_crud(self):
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
         with environment_variable(_BORG_BENCHMARK_CRUD_TEST='YES'):
             self.cmd(f'--repo={self.repository_location}', 'benchmark', 'crud', self.input_path)
 
     def test_config(self):
         self.create_test_files()
         os.unlink('input/flagfile')
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
         output = self.cmd(f'--repo={self.repository_location}', 'config', '--list')
         self.assert_in('[repository]', output)
         self.assert_in('version', output)
@@ -3356,7 +3324,7 @@ id: 2 / e29442 3506da 4e1ea7 / 25f62a 5a3d41 - 02
     def test_export_tar(self):
         self.create_test_files()
         os.unlink('input/flagfile')
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
         self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
         self.cmd(f'--repo={self.repository_location}', 'export-tar', 'test', 'simple.tar', '--progress', '--tar-format=GNU')
         with changedir('output'):
@@ -3371,7 +3339,7 @@ id: 2 / e29442 3506da 4e1ea7 / 25f62a 5a3d41 - 02
             pytest.skip('gzip is not installed')
         self.create_test_files()
         os.unlink('input/flagfile')
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
         self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
         list = self.cmd(f'--repo={self.repository_location}', 'export-tar', 'test', 'simple.tar.gz',
                         '--list', '--tar-format=GNU')
@@ -3387,7 +3355,7 @@ id: 2 / e29442 3506da 4e1ea7 / 25f62a 5a3d41 - 02
             pytest.skip('gzip is not installed')
         self.create_test_files()
         os.unlink('input/flagfile')
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
         self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
         list = self.cmd(f'--repo={self.repository_location}', 'export-tar', 'test', 'simple.tar',
                         '--strip-components=1', '--list', '--tar-format=GNU')
@@ -3497,69 +3465,22 @@ id: 2 / e29442 3506da 4e1ea7 / 25f62a 5a3d41 - 02
         self.assert_in('this-repository-does-not-exist', output)
         self.assert_not_in('this-repository-does-not-exist::test', output)
 
-    def test_can_read_repo_even_if_nonce_is_deleted(self):
-        """Nonce is only used for encrypting new data.
-
-        It should be possible to retrieve the data from an archive even if
-        both the client and the server forget the nonce"""
-        self.create_regular_file('file1', contents=b'Hello, borg')
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
-        self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
-        # Oops! We have removed the repo-side memory of the nonce!
-        # See https://github.com/borgbackup/borg/issues/5858
-        os.remove(os.path.join(self.repository_path, 'nonce'))
-        # Oops! The client has lost the nonce too!
-        os.remove(os.path.join(self.get_security_dir(), 'nonce'))
-
-        # The repo should still be readable
-        repo_info = self.cmd(f'--repo={self.repository_location}', 'rinfo')
-        assert 'Original size:' in repo_info
-        repo_list = self.cmd(f'--repo={self.repository_location}', 'rlist')
-        assert 'test' in repo_list
-        # The archive should still be readable
-        archive_info = self.cmd(f'--repo={self.repository_location}', 'info', '-a', 'test')
-        assert 'Archive name: test\n' in archive_info
-        archive_list = self.cmd(f'--repo={self.repository_location}', 'list', 'test')
-        assert 'file1' in archive_list
-        # Extracting the archive should work
-        with changedir('output'):
-            self.cmd(f'--repo={self.repository_location}', 'extract', 'test')
-        self.assert_dirs_equal('input', 'output/input')
-
-    def test_recovery_from_deleted_repo_nonce(self):
-        """We should be able to recover if path/to/repo/nonce is deleted.
-
-        The nonce is stored in two places: in the repo and in $HOME.
-        The nonce in the repo is only needed when multiple clients use the same
-        repo. Otherwise we can just use our own copy of the nonce.
-        """
-        self.create_regular_file('file1', contents=b'Hello, borg')
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
-        self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
-        # Oops! We have removed the repo-side memory of the nonce!
-        # See https://github.com/borgbackup/borg/issues/5858
-        nonce = os.path.join(self.repository_path, 'nonce')
-        os.remove(nonce)
-
-        self.cmd(f'--repo={self.repository_location}', 'create', 'test2', 'input')
-        assert os.path.exists(nonce)
-
     def test_init_defaults_to_argon2(self):
         """https://github.com/borgbackup/borg/issues/747#issuecomment-1076160401"""
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
         with Repository(self.repository_path) as repository:
             key = msgpack.unpackb(a2b_base64(repository.load_key()))
         assert key['algorithm'] == 'argon2 chacha20-poly1305'
 
     def test_init_with_explicit_key_algorithm(self):
         """https://github.com/borgbackup/borg/issues/747#issuecomment-1076160401"""
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey', '--key-algorithm=pbkdf2')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION, '--key-algorithm=pbkdf2')
         with Repository(self.repository_path) as repository:
             key = msgpack.unpackb(a2b_base64(repository.load_key()))
         assert key['algorithm'] == 'sha256'
 
     def verify_change_passphrase_does_not_change_algorithm(self, given_algorithm, expected_algorithm):
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey', '--key-algorithm', given_algorithm)
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION, '--key-algorithm', given_algorithm)
         os.environ['BORG_NEW_PASSPHRASE'] = 'newpassphrase'
 
         self.cmd(f'--repo={self.repository_location}', 'key', 'change-passphrase')
@@ -3575,7 +3496,7 @@ id: 2 / e29442 3506da 4e1ea7 / 25f62a 5a3d41 - 02
         self.verify_change_passphrase_does_not_change_algorithm('pbkdf2', 'sha256')
 
     def verify_change_location_does_not_change_algorithm(self, given_algorithm, expected_algorithm):
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=keyfile', '--key-algorithm', given_algorithm)
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', KF_ENCRYPTION, '--key-algorithm', given_algorithm)
 
         self.cmd(f'--repo={self.repository_location}', 'key', 'change-location', 'repokey')
 
@@ -3590,7 +3511,7 @@ id: 2 / e29442 3506da 4e1ea7 / 25f62a 5a3d41 - 02
         self.verify_change_location_does_not_change_algorithm('pbkdf2', 'sha256')
 
     def test_key_change_algorithm(self):
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey', '--key-algorithm=pbkdf2')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION, '--key-algorithm=pbkdf2')
 
         self.cmd(f'--repo={self.repository_location}', 'key', 'change-algorithm', 'argon2')
 
@@ -3649,7 +3570,7 @@ class ArchiverCheckTestCase(ArchiverTestCaseBase):
     def setUp(self):
         super().setUp()
         with patch.object(ChunkBuffer, 'BUFFER_SIZE', 10):
-            self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
+            self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
             self.create_src_archive('archive1')
             self.create_src_archive('archive2')
 
@@ -3844,7 +3765,7 @@ class ArchiverCheckTestCase(ArchiverTestCaseBase):
         assert 'testsuite/archiver.py: New missing file chunk detected' in output
 
     def test_verify_data(self):
-        self._test_verify_data('--encryption', 'repokey')
+        self._test_verify_data(RK_ENCRYPTION)
 
     def test_verify_data_unencrypted(self):
         self._test_verify_data('--encryption', 'none')
@@ -3870,7 +3791,7 @@ class ManifestAuthenticationTest(ArchiverTestCaseBase):
             repository.commit(compact=False)
 
     def test_fresh_init_tam_required(self):
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
         repository = Repository(self.repository_path, exclusive=True)
         with repository:
             manifest, key = Manifest.load(repository, Manifest.NO_OPERATION_CHECK)
@@ -3885,7 +3806,7 @@ class ManifestAuthenticationTest(ArchiverTestCaseBase):
             self.cmd(f'--repo={self.repository_location}', 'rlist')
 
     def test_not_required(self):
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
         self.create_src_archive('archive1234')
         repository = Repository(self.repository_path, exclusive=True)
         # Manifest must be authenticated now
@@ -3908,32 +3829,32 @@ class RemoteArchiverTestCase(ArchiverTestCase):
     def test_remote_repo_restrict_to_path(self):
         # restricted to repo directory itself:
         with patch.object(RemoteRepository, 'extra_test_args', ['--restrict-to-path', self.repository_path]):
-            self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
+            self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
         # restricted to repo directory itself, fail for other directories with same prefix:
         with patch.object(RemoteRepository, 'extra_test_args', ['--restrict-to-path', self.repository_path]):
             with pytest.raises(PathNotAllowed):
-                self.cmd(f'--repo={self.repository_location}_0', 'rcreate', '--encryption=repokey')
+                self.cmd(f'--repo={self.repository_location}_0', 'rcreate', RK_ENCRYPTION)
 
         # restricted to a completely different path:
         with patch.object(RemoteRepository, 'extra_test_args', ['--restrict-to-path', '/foo']):
             with pytest.raises(PathNotAllowed):
-                self.cmd(f'--repo={self.repository_location}_1', 'rcreate', '--encryption=repokey')
+                self.cmd(f'--repo={self.repository_location}_1', 'rcreate', RK_ENCRYPTION)
         path_prefix = os.path.dirname(self.repository_path)
         # restrict to repo directory's parent directory:
         with patch.object(RemoteRepository, 'extra_test_args', ['--restrict-to-path', path_prefix]):
-            self.cmd(f'--repo={self.repository_location}_2', 'rcreate', '--encryption=repokey')
+            self.cmd(f'--repo={self.repository_location}_2', 'rcreate', RK_ENCRYPTION)
         # restrict to repo directory's parent directory and another directory:
         with patch.object(RemoteRepository, 'extra_test_args', ['--restrict-to-path', '/foo', '--restrict-to-path', path_prefix]):
-            self.cmd(f'--repo={self.repository_location}_3', 'rcreate', '--encryption=repokey')
+            self.cmd(f'--repo={self.repository_location}_3', 'rcreate', RK_ENCRYPTION)
 
     def test_remote_repo_restrict_to_repository(self):
         # restricted to repo directory itself:
         with patch.object(RemoteRepository, 'extra_test_args', ['--restrict-to-repository', self.repository_path]):
-            self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
+            self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
         parent_path = os.path.join(self.repository_path, '..')
         with patch.object(RemoteRepository, 'extra_test_args', ['--restrict-to-repository', parent_path]):
             with pytest.raises(PathNotAllowed):
-                self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
+                self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
 
     @unittest.skip('only works locally')
     def test_debug_put_get_delete_obj(self):
@@ -3948,7 +3869,7 @@ class RemoteArchiverTestCase(ArchiverTestCase):
         pass
 
     def test_remote_repo_strip_components_doesnt_leak(self):
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
         self.create_regular_file('dir/file', contents=b"test file contents 1")
         self.create_regular_file('dir/file2', contents=b"test file contents 2")
         self.create_regular_file('skipped-file1', contents=b"test file contents 3")
@@ -3974,7 +3895,7 @@ class ArchiverCorruptionTestCase(ArchiverTestCaseBase):
     def setUp(self):
         super().setUp()
         self.create_test_files()
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
         self.cache_path = json.loads(self.cmd(f'--repo={self.repository_location}', 'rinfo', '--json'))['cache']['path']
 
     def corrupt(self, file, amount=1):
@@ -4068,7 +3989,7 @@ class DiffArchiverTestCase(ArchiverTestCaseBase):
             os.link('input/file_removed', 'input/hardlink_removed')
             os.link('input/file_removed2', 'input/hardlink_target_removed')
 
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
 
         # Create the first snapshot
         self.cmd(f'--repo={self.repository_location}', 'create', 'test0', 'input')
@@ -4254,7 +4175,7 @@ class DiffArchiverTestCase(ArchiverTestCaseBase):
         do_json_asserts(self.cmd(f'--repo={self.repository_location}', 'diff', 'test0', 'test1a', '--json-lines'), True)
 
     def test_sort_option(self):
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey')
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
 
         self.create_regular_file('a_file_removed', size=8)
         self.create_regular_file('f_file_removed', size=16)
@@ -4315,7 +4236,7 @@ def test_get_args():
     assert args.restrict_to_repositories == ['/r1', '/r2']
     # trying to cheat - try to execute different subcommand
     args = archiver.get_args(['borg', 'serve', '--restrict-to-path=/p1', '--restrict-to-path=/p2', ],
-                             'borg --repo=/ rcreate --encryption=repokey')
+                             f'borg --repo=/ rcreate {RK_ENCRYPTION}')
     assert args.func == archiver.do_serve
 
     # Check that environment variables in the forced command don't cause issues. If the command

From ef24dafb151f38ec16e11e520c760128212d9a82 Mon Sep 17 00:00:00 2001
From: Thomas Waldmann <tw@waldmann-edv.de>
Date: Thu, 30 Jun 2022 00:15:54 +0200
Subject: [PATCH 090/160] tests: use less RepoKey/KeyfileKey

---
 src/borg/crypto/keymanager.py | 10 +++----
 src/borg/testsuite/cache.py   |  4 +--
 src/borg/testsuite/crypto.py  | 10 +++----
 src/borg/testsuite/key.py     | 50 ++++++++++++++---------------------
 4 files changed, 32 insertions(+), 42 deletions(-)

diff --git a/src/borg/crypto/keymanager.py b/src/borg/crypto/keymanager.py
index 2d41c3022..db5eb23c7 100644
--- a/src/borg/crypto/keymanager.py
+++ b/src/borg/crypto/keymanager.py
@@ -7,7 +7,7 @@ from hashlib import sha256
 from ..helpers import Manifest, NoManifestError, Error, yes, bin_to_hex, dash_open
 from ..repository import Repository
 
-from .key import KeyfileKey, KeyfileNotFoundError, RepoKeyNotFoundError, KeyBlobStorage, identify_key
+from .key import CHPOKeyfileKey, KeyfileNotFoundError, RepoKeyNotFoundError, KeyBlobStorage, identify_key
 
 
 class UnencryptedRepo(Error):
@@ -50,7 +50,7 @@ class KeyManager:
 
     def load_keyblob(self):
         if self.keyblob_storage == KeyBlobStorage.KEYFILE:
-            k = KeyfileKey(self.repository)
+            k = CHPOKeyfileKey(self.repository)
             target = k.find_key()
             with open(target) as fd:
                 self.keyblob = ''.join(fd.readlines()[1:])
@@ -65,7 +65,7 @@ class KeyManager:
 
     def store_keyblob(self, args):
         if self.keyblob_storage == KeyBlobStorage.KEYFILE:
-            k = KeyfileKey(self.repository)
+            k = CHPOKeyfileKey(self.repository)
             target = k.get_existing_or_new_target(args)
 
             self.store_keyfile(target)
@@ -73,7 +73,7 @@ class KeyManager:
             self.repository.save_key(self.keyblob.encode('utf-8'))
 
     def get_keyfile_data(self):
-        data = f'{KeyfileKey.FILE_ID} {bin_to_hex(self.repository.id)}\n'
+        data = f'{CHPOKeyfileKey.FILE_ID} {bin_to_hex(self.repository.id)}\n'
         data += self.keyblob
         if not self.keyblob.endswith('\n'):
             data += '\n'
@@ -136,7 +136,7 @@ class KeyManager:
             fd.write(export)
 
     def import_keyfile(self, args):
-        file_id = KeyfileKey.FILE_ID
+        file_id = CHPOKeyfileKey.FILE_ID
         first_line = file_id + ' ' + bin_to_hex(self.repository.id) + '\n'
         with dash_open(args.path, 'r') as fd:
             file_first_line = fd.read(len(first_line))
diff --git a/src/borg/testsuite/cache.py b/src/borg/testsuite/cache.py
index faff9f2b7..f642a588e 100644
--- a/src/borg/testsuite/cache.py
+++ b/src/borg/testsuite/cache.py
@@ -10,7 +10,7 @@ from .key import TestKey
 from ..archive import Statistics
 from ..cache import AdHocCache
 from ..compress import CompressionSpec
-from ..crypto.key import RepoKey
+from ..crypto.key import AESOCBRepoKey
 from ..hashindex import ChunkIndex, CacheSynchronizer
 from ..helpers import Manifest
 from ..repository import Repository
@@ -218,7 +218,7 @@ class TestAdHocCache:
     @pytest.fixture
     def key(self, repository, monkeypatch):
         monkeypatch.setenv('BORG_PASSPHRASE', 'test')
-        key = RepoKey.create(repository, TestKey.MockArgs())
+        key = AESOCBRepoKey.create(repository, TestKey.MockArgs())
         key.compressor = CompressionSpec('none').compressor
         return key
 
diff --git a/src/borg/testsuite/crypto.py b/src/borg/testsuite/crypto.py
index e691c3210..e131f63ac 100644
--- a/src/borg/testsuite/crypto.py
+++ b/src/borg/testsuite/crypto.py
@@ -9,7 +9,7 @@ from ..crypto.low_level import AES256_CTR_HMAC_SHA256, AES256_OCB, CHACHA20_POLY
 from ..crypto.low_level import bytes_to_long, bytes_to_int, long_to_bytes
 from ..crypto.low_level import hkdf_hmac_sha512
 from ..crypto.low_level import AES, hmac_sha256
-from ..crypto.key import KeyfileKey, RepoKey, FlexiKey
+from ..crypto.key import CHPOKeyfileKey, AESOCBRepoKey, FlexiKey
 from ..helpers import msgpack
 
 from . import BaseTestCase
@@ -264,7 +264,7 @@ def test_decrypt_key_file_argon2_chacha20_poly1305():
         'algorithm': 'argon2 chacha20-poly1305',
         'data': envelope,
     })
-    key = KeyfileKey(None)
+    key = CHPOKeyfileKey(None)
 
     decrypted = key.decrypt_key_file(encrypted, "hello, pass phrase")
 
@@ -286,7 +286,7 @@ def test_decrypt_key_file_pbkdf2_sha256_aes256_ctr_hmac_sha256():
         'data': data,
         'hash': hash,
     })
-    key = KeyfileKey(None)
+    key = CHPOKeyfileKey(None)
 
     decrypted = key.decrypt_key_file(encrypted, passphrase)
 
@@ -325,7 +325,7 @@ def test_repo_key_detect_does_not_raise_integrity_error(getpass, monkeypatch):
     repository = MagicMock(id=b'repository_id')
     getpass.return_value = "hello, pass phrase"
     monkeypatch.setenv('BORG_DISPLAY_PASSPHRASE', 'no')
-    RepoKey.create(repository, args=MagicMock(key_algorithm='argon2'))
+    AESOCBRepoKey.create(repository, args=MagicMock(key_algorithm='argon2'))
     repository.load_key.return_value = repository.save_key.call_args.args[0]
 
-    RepoKey.detect(repository, manifest_data=None)
+    AESOCBRepoKey.detect(repository, manifest_data=None)
diff --git a/src/borg/testsuite/key.py b/src/borg/testsuite/key.py
index 02eaa86e5..01db16335 100644
--- a/src/borg/testsuite/key.py
+++ b/src/borg/testsuite/key.py
@@ -8,9 +8,10 @@ from unittest.mock import MagicMock
 import pytest
 
 from ..crypto.key import bin_to_hex
-from ..crypto.key import PlaintextKey, AuthenticatedKey, RepoKey, KeyfileKey, \
-    Blake2KeyfileKey, Blake2RepoKey, Blake2AuthenticatedKey, \
-    AESOCBKeyfileKey, AESOCBRepoKey, CHPOKeyfileKey, CHPORepoKey
+from ..crypto.key import PlaintextKey, AuthenticatedKey, Blake2AuthenticatedKey
+from ..crypto.key import RepoKey, KeyfileKey, Blake2RepoKey, Blake2KeyfileKey
+from ..crypto.key import AESOCBRepoKey, AESOCBKeyfileKey, CHPORepoKey, CHPOKeyfileKey
+from ..crypto.key import Blake2AESOCBRepoKey, Blake2AESOCBKeyfileKey, Blake2CHPORepoKey, Blake2CHPOKeyfileKey
 from ..crypto.key import ID_HMAC_SHA_256, ID_BLAKE2b_256
 from ..crypto.key import TAMRequiredError, TAMInvalid, TAMUnsupportedSuiteError, UnsupportedManifestError, UnsupportedKeyFormatError
 from ..crypto.key import identify_key
@@ -76,16 +77,17 @@ class TestKey:
         return tmpdir
 
     @pytest.fixture(params=(
+        # not encrypted
         PlaintextKey,
-        AuthenticatedKey,
-        KeyfileKey,
-        RepoKey,
-        AuthenticatedKey,
-        Blake2KeyfileKey,
-        Blake2RepoKey,
-        Blake2AuthenticatedKey,
+        AuthenticatedKey, Blake2AuthenticatedKey,
+        # legacy crypto
+        KeyfileKey, Blake2KeyfileKey,
+        RepoKey, Blake2RepoKey,
+        # new crypto
         AESOCBKeyfileKey, AESOCBRepoKey,
+        Blake2AESOCBKeyfileKey, Blake2AESOCBRepoKey,
         CHPOKeyfileKey, CHPORepoKey,
+        Blake2CHPOKeyfileKey, Blake2CHPORepoKey,
     ))
     def key(self, request, monkeypatch):
         monkeypatch.setenv('BORG_PASSPHRASE', 'test')
@@ -143,33 +145,21 @@ class TestKey:
         id = key.id_hash(chunk)
         assert chunk == key2.decrypt(id, key.encrypt(id, chunk))
 
-    def test_keyfile_nonce_rollback_protection(self, monkeypatch, keys_dir):
-        monkeypatch.setenv('BORG_PASSPHRASE', 'test')
-        repository = self.MockRepository()
-        with open(os.path.join(get_security_dir(repository.id_str), 'nonce'), "w") as fd:
-            fd.write("0000000000002000")
-        key = KeyfileKey.create(repository, self.MockArgs())
-        chunk = b'ABC'
-        id = key.id_hash(chunk)
-        data = key.encrypt(id, chunk)
-        assert key.cipher.extract_iv(data) == 0x2000
-        assert key.decrypt(id, data) == chunk
-
     def test_keyfile_kfenv(self, tmpdir, monkeypatch):
         keyfile = tmpdir.join('keyfile')
         monkeypatch.setenv('BORG_KEY_FILE', str(keyfile))
         monkeypatch.setenv('BORG_PASSPHRASE', 'testkf')
         assert not keyfile.exists()
-        key = KeyfileKey.create(self.MockRepository(), self.MockArgs())
+        key = CHPOKeyfileKey.create(self.MockRepository(), self.MockArgs())
         assert keyfile.exists()
         chunk = b'ABC'
         chunk_id = key.id_hash(chunk)
         chunk_cdata = key.encrypt(chunk_id, chunk)
-        key = KeyfileKey.detect(self.MockRepository(), chunk_cdata)
+        key = CHPOKeyfileKey.detect(self.MockRepository(), chunk_cdata)
         assert chunk == key.decrypt(chunk_id, chunk_cdata)
         keyfile.remove()
         with pytest.raises(FileNotFoundError):
-            KeyfileKey.detect(self.MockRepository(), chunk_cdata)
+            CHPOKeyfileKey.detect(self.MockRepository(), chunk_cdata)
 
     def test_keyfile2(self, monkeypatch, keys_dir):
         with keys_dir.join('keyfile').open('w') as fd:
@@ -275,7 +265,7 @@ class TestTAM:
     @pytest.fixture
     def key(self, monkeypatch):
         monkeypatch.setenv('BORG_PASSPHRASE', 'test')
-        return KeyfileKey.create(TestKey.MockRepository(), TestKey.MockArgs())
+        return CHPOKeyfileKey.create(TestKey.MockRepository(), TestKey.MockArgs())
 
     def test_unpack_future(self, key):
         blob = b'\xc1\xc1\xc1\xc1foobar'
@@ -385,7 +375,7 @@ class TestTAM:
 
 def test_decrypt_key_file_unsupported_algorithm():
     """We will add more algorithms in the future. We should raise a helpful error."""
-    key = KeyfileKey(None)
+    key = CHPOKeyfileKey(None)
     encrypted = msgpack.packb({
         'algorithm': 'THIS ALGORITHM IS NOT SUPPORTED',
         'version': 1,
@@ -397,7 +387,7 @@ def test_decrypt_key_file_unsupported_algorithm():
 
 def test_decrypt_key_file_v2_is_unsupported():
     """There may eventually be a version 2 of the format. For now we should raise a helpful error."""
-    key = KeyfileKey(None)
+    key = CHPOKeyfileKey(None)
     encrypted = msgpack.packb({
         'version': 2,
     })
@@ -415,10 +405,10 @@ def test_key_file_roundtrip(monkeypatch, cli_argument, expected_algorithm):
     repository = MagicMock(id=b'repository_id')
     monkeypatch.setenv('BORG_PASSPHRASE', "hello, pass phrase")
 
-    save_me = RepoKey.create(repository, args=MagicMock(key_algorithm=cli_argument))
+    save_me = AESOCBRepoKey.create(repository, args=MagicMock(key_algorithm=cli_argument))
     saved = repository.save_key.call_args.args[0]
     repository.load_key.return_value = saved
-    load_me = RepoKey.detect(repository, manifest_data=None)
+    load_me = AESOCBRepoKey.detect(repository, manifest_data=None)
 
     assert to_dict(load_me) == to_dict(save_me)
     assert msgpack.unpackb(a2b_base64(saved))['algorithm'] == expected_algorithm

From eabad3e3b7fc0c301e0b390a141dcbaad28095ff Mon Sep 17 00:00:00 2001
From: Thomas Waldmann <tw@waldmann-edv.de>
Date: Thu, 30 Jun 2022 01:13:49 +0200
Subject: [PATCH 091/160] rcreate: always use argon2 kdf for new repos, fixes
 #6820

this way, we can remove the legacy pbkdf2 key code in next release.
---
 setup_docs.py                  |  1 -
 src/borg/archiver.py           | 58 ----------------------------------
 src/borg/crypto/key.py         |  2 +-
 src/borg/crypto/low_level.pyx  |  2 +-
 src/borg/testsuite/archiver.py | 41 ++++--------------------
 src/borg/testsuite/key.py      |  7 ++--
 6 files changed, 11 insertions(+), 100 deletions(-)

diff --git a/setup_docs.py b/setup_docs.py
index 2f9dcb35d..7d985ebff 100644
--- a/setup_docs.py
+++ b/setup_docs.py
@@ -303,7 +303,6 @@ class build_man(Command):
 
         'key_change-passphrase': 'key',
         'key_change-location': 'key',
-        'key_change-algorithm': 'key',
         'key_export': 'key',
         'key_import': 'key',
         'key_migrate-to-repokey': 'key',
diff --git a/src/borg/archiver.py b/src/borg/archiver.py
index 1bb4c1487..d61ead194 100644
--- a/src/borg/archiver.py
+++ b/src/borg/archiver.py
@@ -4380,22 +4380,6 @@ class Archiver:
         If you do **not** want to encrypt the contents of your backups, but still want to detect
         malicious tampering use an `authenticated` mode. It's like `repokey` minus encryption.
 
-        Key derivation functions
-        ++++++++++++++++++++++++
-
-        - ``--key-algorithm argon2`` is the default and is recommended.
-          The key encryption key is derived from your passphrase via argon2-id.
-          Argon2 is considered more modern and secure than pbkdf2.
-
-        Our implementation of argon2-based key algorithm follows the cryptographic best practices:
-
-        - It derives two separate keys from your passphrase: one to encrypt your key and another one
-          to sign it. ``--key-algorithm pbkdf2`` uses the same key for both.
-
-        - It uses encrypt-then-mac instead of encrypt-and-mac used by ``--key-algorithm pbkdf2``
-
-        Neither is inherently linked to the key derivation function, but since we were going
-        to break backwards compatibility anyway we took the opportunity to fix all 3 issues at once.
         """)
         subparser = subparsers.add_parser('rcreate', parents=[common_parser], add_help=False,
                                           description=self.do_rcreate.__doc__, epilog=rcreate_epilog,
@@ -4418,8 +4402,6 @@ class Archiver:
                                help='Set storage quota of the new repository (e.g. 5G, 1.5T). Default: no quota.')
         subparser.add_argument('--make-parent-dirs', dest='make_parent_dirs', action='store_true',
                                help='create the parent directories of the repository directory, if they are missing.')
-        subparser.add_argument('--key-algorithm', dest='key_algorithm', default='argon2', choices=list(KEY_ALGORITHMS),
-                               help='the algorithm we use to derive a key encryption key from your passphrase. Default: argon2')
 
         # borg key
         subparser = subparsers.add_parser('key', parents=[mid_common_parser], add_help=False,
@@ -4544,46 +4526,6 @@ class Archiver:
         subparser.add_argument('--keep', dest='keep', action='store_true',
                                help='keep the key also at the current location (default: remove it)')
 
-        change_algorithm_epilog = process_epilog("""
-        Change the algorithm we use to encrypt and authenticate the borg key.
-
-        Important: In a `repokey` mode (e.g. repokey-blake2) all users share the same key.
-        In this mode upgrading to `argon2` will make it impossible to access the repo for users who use an old version of borg.
-        We recommend upgrading to the latest stable version.
-
-        Important: In a `keyfile` mode (e.g. keyfile-blake2) each user has their own key (in ``~/.config/borg/keys``).
-        In this mode this command will only change the key used by the current user.
-        If you want to upgrade to `argon2` to strengthen security, you will have to upgrade each user's key individually.
-
-        Your repository is encrypted and authenticated with a key that is randomly generated by ``borg init``.
-        The key is encrypted and authenticated with your passphrase.
-
-        We currently support two choices:
-
-        1. argon2 - recommended. This algorithm is used by default when initialising a new repository.
-           The key encryption key is derived from your passphrase via argon2-id.
-           Argon2 is considered more modern and secure than pbkdf2.
-        2. pbkdf2 - the legacy algorithm. Use this if you want to access your repo via old versions of borg.
-           The key encryption key is derived from your passphrase via PBKDF2-HMAC-SHA256.
-
-        Examples::
-
-            # Upgrade an existing key to argon2
-            borg key change-algorithm /path/to/repo argon2
-            # Downgrade to pbkdf2 - use this if upgrading borg is not an option
-            borg key change-algorithm /path/to/repo pbkdf2
-
-
-        """)
-        subparser = key_parsers.add_parser('change-algorithm', parents=[common_parser], add_help=False,
-                                           description=self.do_change_algorithm.__doc__,
-                                           epilog=change_algorithm_epilog,
-                                           formatter_class=argparse.RawDescriptionHelpFormatter,
-                                           help='change key algorithm')
-        subparser.set_defaults(func=self.do_change_algorithm)
-        subparser.add_argument('algorithm', metavar='ALGORITHM', choices=list(KEY_ALGORITHMS),
-                               help='select key algorithm')
-
         # borg list
         list_epilog = process_epilog("""
         This command lists the contents of an archive.
diff --git a/src/borg/crypto/key.py b/src/borg/crypto/key.py
index e1c58c47a..cd1fd9324 100644
--- a/src/borg/crypto/key.py
+++ b/src/borg/crypto/key.py
@@ -620,7 +620,7 @@ class FlexiKey:
             passphrase = Passphrase.new(allow_empty=True)
         key.init_ciphers()
         target = key.get_new_target(args)
-        key.save(target, passphrase, create=True, algorithm=KEY_ALGORITHMS[args.key_algorithm])
+        key.save(target, passphrase, create=True, algorithm=KEY_ALGORITHMS['argon2'])
         logger.info('Key in "%s" created.' % target)
         logger.info('Keep this key safe. Your data will be inaccessible without it.')
         return key
diff --git a/src/borg/crypto/low_level.pyx b/src/borg/crypto/low_level.pyx
index c0818abc5..d44160b50 100644
--- a/src/borg/crypto/low_level.pyx
+++ b/src/borg/crypto/low_level.pyx
@@ -613,7 +613,7 @@ cdef class CHACHA20_POLY1305(_AEAD_BASE):
         super().__init__(key, iv=iv, header_len=header_len, aad_offset=aad_offset)
 
 
-cdef class AES:
+cdef class AES:  # legacy
     """A thin wrapper around the OpenSSL EVP cipher API - for legacy code, like key file encryption"""
     cdef CIPHER cipher
     cdef EVP_CIPHER_CTX *ctx
diff --git a/src/borg/testsuite/archiver.py b/src/borg/testsuite/archiver.py
index 7c34da238..6fda62be7 100644
--- a/src/borg/testsuite/archiver.py
+++ b/src/borg/testsuite/archiver.py
@@ -3472,53 +3472,24 @@ id: 2 / e29442 3506da 4e1ea7 / 25f62a 5a3d41 - 02
             key = msgpack.unpackb(a2b_base64(repository.load_key()))
         assert key['algorithm'] == 'argon2 chacha20-poly1305'
 
-    def test_init_with_explicit_key_algorithm(self):
-        """https://github.com/borgbackup/borg/issues/747#issuecomment-1076160401"""
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION, '--key-algorithm=pbkdf2')
-        with Repository(self.repository_path) as repository:
-            key = msgpack.unpackb(a2b_base64(repository.load_key()))
-        assert key['algorithm'] == 'sha256'
-
-    def verify_change_passphrase_does_not_change_algorithm(self, given_algorithm, expected_algorithm):
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION, '--key-algorithm', given_algorithm)
+    def test_change_passphrase_does_not_change_algorithm_argon2(self):
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
         os.environ['BORG_NEW_PASSPHRASE'] = 'newpassphrase'
 
         self.cmd(f'--repo={self.repository_location}', 'key', 'change-passphrase')
 
         with Repository(self.repository_path) as repository:
             key = msgpack.unpackb(a2b_base64(repository.load_key()))
-            assert key['algorithm'] == expected_algorithm
+            assert key['algorithm'] == 'argon2 chacha20-poly1305'
 
-    def test_change_passphrase_does_not_change_algorithm_argon2(self):
-        self.verify_change_passphrase_does_not_change_algorithm('argon2', 'argon2 chacha20-poly1305')
-
-    def test_change_passphrase_does_not_change_algorithm_pbkdf2(self):
-        self.verify_change_passphrase_does_not_change_algorithm('pbkdf2', 'sha256')
-
-    def verify_change_location_does_not_change_algorithm(self, given_algorithm, expected_algorithm):
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', KF_ENCRYPTION, '--key-algorithm', given_algorithm)
+    def test_change_location_does_not_change_algorithm_argon2(self):
+        self.cmd(f'--repo={self.repository_location}', 'rcreate', KF_ENCRYPTION)
 
         self.cmd(f'--repo={self.repository_location}', 'key', 'change-location', 'repokey')
 
         with Repository(self.repository_path) as repository:
             key = msgpack.unpackb(a2b_base64(repository.load_key()))
-            assert key['algorithm'] == expected_algorithm
-
-    def test_change_location_does_not_change_algorithm_argon2(self):
-        self.verify_change_location_does_not_change_algorithm('argon2', 'argon2 chacha20-poly1305')
-
-    def test_change_location_does_not_change_algorithm_pbkdf2(self):
-        self.verify_change_location_does_not_change_algorithm('pbkdf2', 'sha256')
-
-    def test_key_change_algorithm(self):
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION, '--key-algorithm=pbkdf2')
-
-        self.cmd(f'--repo={self.repository_location}', 'key', 'change-algorithm', 'argon2')
-
-        with Repository(self.repository_path) as repository:
-            _, key = Manifest.load(repository, Manifest.NO_OPERATION_CHECK)
-        assert key._encrypted_key_algorithm == 'argon2 chacha20-poly1305'
-        self.cmd(f'--repo={self.repository_location}', 'rinfo')
+            assert key['algorithm'] == 'argon2 chacha20-poly1305'
 
 
 @unittest.skipUnless('binary' in BORG_EXES, 'no borg.exe available')
diff --git a/src/borg/testsuite/key.py b/src/borg/testsuite/key.py
index 01db16335..b202d1078 100644
--- a/src/borg/testsuite/key.py
+++ b/src/borg/testsuite/key.py
@@ -396,8 +396,7 @@ def test_decrypt_key_file_v2_is_unsupported():
         key.decrypt_key_file(encrypted, "hello, pass phrase")
 
 
-@pytest.mark.parametrize('cli_argument, expected_algorithm', KEY_ALGORITHMS.items())
-def test_key_file_roundtrip(monkeypatch, cli_argument, expected_algorithm):
+def test_key_file_roundtrip(monkeypatch):
     def to_dict(key):
         extract = 'repository_id', 'enc_key', 'enc_hmac_key', 'id_key', 'chunk_seed'
         return {a: getattr(key, a) for a in extract}
@@ -405,10 +404,10 @@ def test_key_file_roundtrip(monkeypatch, cli_argument, expected_algorithm):
     repository = MagicMock(id=b'repository_id')
     monkeypatch.setenv('BORG_PASSPHRASE', "hello, pass phrase")
 
-    save_me = AESOCBRepoKey.create(repository, args=MagicMock(key_algorithm=cli_argument))
+    save_me = AESOCBRepoKey.create(repository, args=MagicMock(key_algorithm='argon2'))
     saved = repository.save_key.call_args.args[0]
     repository.load_key.return_value = saved
     load_me = AESOCBRepoKey.detect(repository, manifest_data=None)
 
     assert to_dict(load_me) == to_dict(save_me)
-    assert msgpack.unpackb(a2b_base64(saved))['algorithm'] == expected_algorithm
+    assert msgpack.unpackb(a2b_base64(saved))['algorithm'] == KEY_ALGORITHMS['argon2']

From b0b5a2fd27aa5a56f7d62434f18f14a9b8e11a26 Mon Sep 17 00:00:00 2001
From: Thomas Waldmann <tw@waldmann-edv.de>
Date: Thu, 30 Jun 2022 23:55:51 +0200
Subject: [PATCH 092/160] add repository.info(), giving some basic repo infos

there was no way to tell the repository version for a remote repo.
borg 2 needs that to reject doing most operations with an old repo,
except the stuff needed for borg transfer.
---
 src/borg/archiver.py   | 4 ++++
 src/borg/remote.py     | 9 +++++++++
 src/borg/repository.py | 8 ++++++++
 3 files changed, 21 insertions(+)

diff --git a/src/borg/archiver.py b/src/borg/archiver.py
index d61ead194..816cc9e7e 100644
--- a/src/borg/archiver.py
+++ b/src/borg/archiver.py
@@ -1692,12 +1692,16 @@ class Archiver:
             print(textwrap.dedent("""
             Repository ID: {id}
             Location: {location}
+            Repository version: {version}
+            Append only: {append_only}
             {encryption}
             Cache: {cache.path}
             Security dir: {security_dir}
             """).strip().format(
                 id=bin_to_hex(repository.id),
                 location=repository._location.canonical_path(),
+                version=repository.version,
+                append_only=repository.append_only,
                 **info))
             print(str(cache))
         return self.exit_code
diff --git a/src/borg/remote.py b/src/borg/remote.py
index ac7255aa7..22b078dcd 100644
--- a/src/borg/remote.py
+++ b/src/borg/remote.py
@@ -133,6 +133,7 @@ compatMap = {
     'break_lock': (),
     'negotiate': ('client_data', ),
     'open': ('path', 'create', 'lock_wait', 'lock', 'exclusive', 'append_only', ),
+    'info': (),
     'get_free_nonce': (),
     'commit_nonce_reservation': ('next_unreserved', 'start_nonce', ),
 }
@@ -150,6 +151,7 @@ class RepositoryServer:  # pragma: no cover
         'scan',
         'negotiate',
         'open',
+        'info',
         'put',
         'rollback',
         'save_key',
@@ -580,6 +582,9 @@ class RemoteRepository:
                 self.id = self.open(path=self.location.path, create=create, lock_wait=lock_wait,
                                     lock=lock, exclusive=exclusive, append_only=append_only,
                                     make_parent_dirs=make_parent_dirs)
+                info = self.info()
+                self.version = info['version']
+                self.append_only = info['append_only']
 
             if self.dictFormat:
                 do_open()
@@ -898,6 +903,10 @@ This problem will go away as soon as the server has been upgraded to 1.0.7+.
              make_parent_dirs=False):
         """actual remoting is done via self.call in the @api decorator"""
 
+    @api(since=parse_version('2.0.0a3'))
+    def info(self):
+        """actual remoting is done via self.call in the @api decorator"""
+
     @api(since=parse_version('1.0.0'),
          max_duration={'since': parse_version('1.2.0a4'), 'previously': 0})
     def check(self, repair=False, save_space=False, max_duration=0):
diff --git a/src/borg/repository.py b/src/borg/repository.py
index d31d4a9d6..ba193243c 100644
--- a/src/borg/repository.py
+++ b/src/borg/repository.py
@@ -491,6 +491,14 @@ class Repository:
                 self.close()
                 raise self.AtticRepository(path)
 
+    def info(self):
+        """return some infos about the repo (must be opened first)"""
+        return dict(
+            id=self.id,
+            version=self.version,
+            append_only=self.append_only,
+        )
+
     def close(self):
         if self.lock:
             if self.io:

From a7870ab5bd481815b815cd856111223ee53bcb1a Mon Sep 17 00:00:00 2001
From: Thomas Waldmann <tw@waldmann-edv.de>
Date: Fri, 1 Jul 2022 00:15:13 +0200
Subject: [PATCH 093/160] only accept old repos for --other-repo (e.g.
 rcreate/transfer)

we do not want to run the new borg code against old repos.

if you want to e.g. check an old repo, use an old borg version.
---
 src/borg/archiver.py | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/src/borg/archiver.py b/src/borg/archiver.py
index 816cc9e7e..d0ef9338b 100644
--- a/src/borg/archiver.py
+++ b/src/borg/archiver.py
@@ -191,6 +191,9 @@ def with_repository(fake=False, invert_fake=False, create=False, lock=True,
                                         args=args)
 
             with repository:
+                if repository.version not in (2, ):
+                    raise Error("This borg version only accepts version 2 repos for -r/--repo. "
+                                "You can use 'borg transfer' to copy archives from old to new repos.")
                 if manifest or cache:
                     kwargs['manifest'], kwargs['key'] = Manifest.load(repository, compatibility)
                     if 'compression' in args:
@@ -233,6 +236,8 @@ def with_other_repository(manifest=False, key=False, cache=False, compatibility=
                                         args=args)
 
             with repository:
+                if repository.version not in (1, 2, ):
+                    raise Error("This borg version only accepts version 1 or 2 repos for --other-repo.")
                 kwargs['other_repository'] = repository
                 if manifest or key or cache:
                     manifest_, key_ = Manifest.load(repository, compatibility)

From 6888d5dcb2293aceaa9494b76ae4771ded4bf2ca Mon Sep 17 00:00:00 2001
From: Thomas Waldmann <tw@waldmann-edv.de>
Date: Sat, 2 Jul 2022 20:52:41 +0200
Subject: [PATCH 094/160] remove -P (aka --prefix) option, fixes #6806

-a (aka --glob-archives) can be used for same purpose and is more powerful.
---
 docs/faq.rst                   |  5 ++---
 docs/quickstart.rst            |  4 ++--
 docs/usage/delete.rst          |  2 +-
 docs/usage/prune.rst           |  6 +++---
 src/borg/archiver.py           | 25 ++++++++-----------------
 src/borg/helpers/manifest.py   |  4 +---
 src/borg/testsuite/archiver.py | 18 +++++++++---------
 7 files changed, 26 insertions(+), 38 deletions(-)

diff --git a/docs/faq.rst b/docs/faq.rst
index 9566fdec7..abf8fed23 100644
--- a/docs/faq.rst
+++ b/docs/faq.rst
@@ -402,11 +402,10 @@ different prefixes. For example, you could have a script that does::
 
 Then you would have two different prune calls with different policies::
 
-    borg prune --verbose --list -d 30 --prefix main-
-    borg prune --verbose --list -d 7  --prefix logs-
+    borg prune --verbose --list -d 30 -a 'main-*'
+    borg prune --verbose --list -d 7  -a 'logs-*'
 
 This will keep 7 days of logs and 30 days of everything else.
-Borg also supports the ``--glob-archives`` parameter.
 
 How do I remove files from an existing backup?
 ----------------------------------------------
diff --git a/docs/quickstart.rst b/docs/quickstart.rst
index 5c33d3857..af14815d9 100644
--- a/docs/quickstart.rst
+++ b/docs/quickstart.rst
@@ -195,13 +195,13 @@ backed up and that the ``prune`` command is keeping and deleting the correct bac
     info "Pruning repository"
 
     # Use the `prune` subcommand to maintain 7 daily, 4 weekly and 6 monthly
-    # archives of THIS machine. The '{hostname}-' prefix is very important to
+    # archives of THIS machine. The '{hostname}-*' globbing is very important to
     # limit prune's operation to this machine's archives and not apply to
     # other machines' archives also:
 
     borg prune                          \
         --list                          \
-        --prefix '{hostname}-'          \
+        --glob-archives '{hostname}-*'  \
         --show-rc                       \
         --keep-daily    7               \
         --keep-weekly   4               \
diff --git a/docs/usage/delete.rst b/docs/usage/delete.rst
index d3f44a066..56fc6e4e8 100644
--- a/docs/usage/delete.rst
+++ b/docs/usage/delete.rst
@@ -10,7 +10,7 @@ Examples
     $ borg compact
 
     # delete all archives whose names begin with the machine's hostname followed by "-"
-    $ borg delete --prefix '{hostname}-'
+    $ borg delete -a '{hostname}-*'
 
     # delete all archives whose names contain "-2012-"
     $ borg delete -a '*-2012-*'
diff --git a/docs/usage/prune.rst b/docs/usage/prune.rst
index 44880adb8..602385de5 100644
--- a/docs/usage/prune.rst
+++ b/docs/usage/prune.rst
@@ -7,8 +7,8 @@ Be careful, prune is a potentially dangerous command, it will remove backup
 archives.
 
 The default of prune is to apply to **all archives in the repository** unless
-you restrict its operation to a subset of the archives using ``--prefix``.
-When using ``--prefix``, be careful to choose a good prefix - e.g. do not use a
+you restrict its operation to a subset of the archives using ``-a`` / ``--glob-archives``.
+When using ``-a``, be careful to choose a good pattern - e.g. do not use a
 prefix "foo" if you do not also want to match "foobar".
 
 It is strongly recommended to always run ``prune -v --list --dry-run ...``
@@ -22,7 +22,7 @@ first so you will see what it would do without it actually doing anything.
 
     # Same as above but only apply to archive names starting with the hostname
     # of the machine followed by a "-" character:
-    $ borg prune -v --list --keep-daily=7 --keep-weekly=4 --prefix='{hostname}-'
+    $ borg prune -v --list --keep-daily=7 --keep-weekly=4 -a '{hostname}-*'
     # actually free disk space:
     $ borg compact
 
diff --git a/src/borg/archiver.py b/src/borg/archiver.py
index d61ead194..2777303c1 100644
--- a/src/borg/archiver.py
+++ b/src/borg/archiver.py
@@ -459,8 +459,8 @@ class Archiver:
                        env_var_override='BORG_CHECK_I_KNOW_WHAT_I_AM_DOING'):
                 return EXIT_ERROR
         if args.repo_only and any(
-           (args.verify_data, args.first, args.last, args.prefix is not None, args.glob_archives)):
-            self.print_error("--repository-only contradicts --first, --last, --prefix, --glob-archives "
+           (args.verify_data, args.first, args.last, args.glob_archives)):
+            self.print_error("--repository-only contradicts --first, --last, -a / --glob-archives "
                              " and --verify-data arguments.")
             return EXIT_ERROR
         if args.repair and args.max_duration:
@@ -476,8 +476,6 @@ class Archiver:
         if not args.archives_only:
             if not repository.check(repair=args.repair, save_space=args.save_space, max_duration=args.max_duration):
                 return EXIT_WARNING
-        if args.prefix is not None:
-            args.glob_archives = args.prefix + '*'
         if not args.repo_only and not ArchiveChecker().check(repository, repair=args.repair,
                 first=args.first, last=args.last, sort_by=args.sort_by or 'ts', glob=args.glob_archives,
                 verify_data=args.verify_data, save_space=args.save_space):
@@ -1757,8 +1755,6 @@ class Archiver:
                              '"keep-secondly", "keep-minutely", "keep-hourly", "keep-daily", '
                              '"keep-weekly", "keep-monthly" or "keep-yearly" settings must be specified.')
             return self.exit_code
-        if args.prefix is not None:
-            args.glob_archives = args.prefix + '*'
         checkpoint_re = r'\.checkpoint(\.\d+)?'
         archives_checkpoints = manifest.archives.list(glob=args.glob_archives,
                                                       consider_checkpoints=True,
@@ -2652,7 +2648,7 @@ class Archiver:
         This allows you to share the same patterns between multiple repositories
         without needing to specify them on the command line.\n\n''')
     helptext['placeholders'] = textwrap.dedent('''
-        Repository URLs, ``--name``, ``--prefix``, ``--glob-archives``, ``--comment``
+        Repository URLs, ``--name``, ``-a`` / ``--glob-archives``, ``--comment``
         and ``--remote-path`` values support these placeholders:
 
         {hostname}
@@ -2698,7 +2694,7 @@ class Archiver:
 
             borg create /path/to/repo::{hostname}-{user}-{utcnow} ...
             borg create /path/to/repo::{hostname}-{now:%Y-%m-%d_%H:%M:%S} ...
-            borg prune --prefix '{hostname}-' ...
+            borg prune -a '{hostname}-*' ...
 
         .. note::
             systemd uses a difficult, non-standard syntax for command lines in unit files (refer to
@@ -3091,13 +3087,10 @@ class Archiver:
             filters_group = subparser.add_argument_group('Archive filters',
                                                          'Archive filters can be applied to repository targets.')
             group = filters_group.add_mutually_exclusive_group()
-            group.add_argument('-P', '--prefix', metavar='PREFIX', dest='prefix', type=PrefixSpec, action=Highlander,
-                               help='only consider archive names starting with this prefix.')
             group.add_argument('-a', '--glob-archives', metavar='GLOB', dest='glob_archives',
                                type=GlobSpec, action=Highlander,
                                help='only consider archive names matching the glob. '
-                                    'sh: rules apply, see "borg help patterns". '
-                                    '``--prefix`` and ``--glob-archives`` are mutually exclusive.')
+                                    'sh: rules apply, see "borg help patterns".')
 
             if sort_by:
                 sort_by_default = 'timestamp'
@@ -3971,11 +3964,9 @@ class Archiver:
         that is how much your repository will shrink.
         Please note that the "All archives" stats refer to the state after deletion.
 
-        You can delete multiple archives by specifying their common prefix, if they
-        have one, using the ``--prefix PREFIX`` option. You can also specify a shell
-        pattern to match multiple archives using the ``--glob-archives GLOB`` option
-        (for more info on these patterns, see :ref:`borg_patterns`). Note that these
-        two options are mutually exclusive.
+        You can delete multiple archives by specifying a matching shell pattern,
+        using the ``--glob-archives GLOB`` option (for more info on these patterns,
+        see :ref:`borg_patterns`).
 
         Always first use ``--dry-run --list`` to see what would be deleted.
         """)
diff --git a/src/borg/helpers/manifest.py b/src/borg/helpers/manifest.py
index 786eb27bb..f2eeaad68 100644
--- a/src/borg/helpers/manifest.py
+++ b/src/borg/helpers/manifest.py
@@ -106,9 +106,7 @@ class Archives(abc.MutableMapping):
         name = getattr(args, 'name', None)
         consider_checkpoints = getattr(args, 'consider_checkpoints', None)
         if name is not None:
-            raise Error('Giving a specific name is incompatible with options --first, --last, --prefix, and --glob-archives, and --consider-checkpoints.')
-        if args.prefix is not None:
-            args.glob_archives = args.prefix + '*'
+            raise Error('Giving a specific name is incompatible with options --first, --last, -a / --glob-archives, and --consider-checkpoints.')
         return self.list(sort_by=args.sort_by.split(','), consider_checkpoints=consider_checkpoints, glob=args.glob_archives, first=args.first, last=args.last)
 
     def set_raw_dict(self, d):
diff --git a/src/borg/testsuite/archiver.py b/src/borg/testsuite/archiver.py
index 6fda62be7..d568d2a9c 100644
--- a/src/borg/testsuite/archiver.py
+++ b/src/borg/testsuite/archiver.py
@@ -1600,7 +1600,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self.cmd(f'--repo={self.repository_location}', 'create', 'another_test.2', 'input')
         self.cmd(f'--repo={self.repository_location}', 'extract', 'test', '--dry-run')
         self.cmd(f'--repo={self.repository_location}', 'extract', 'test.2', '--dry-run')
-        self.cmd(f'--repo={self.repository_location}', 'delete', '--prefix', 'another_')
+        self.cmd(f'--repo={self.repository_location}', 'delete', '--glob-archives', 'another_*')
         self.cmd(f'--repo={self.repository_location}', 'delete', '--last', '1')
         self.cmd(f'--repo={self.repository_location}', 'delete', '-a', 'test')
         self.cmd(f'--repo={self.repository_location}', 'extract', 'test.2', '--dry-run')
@@ -2259,7 +2259,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self.cmd(f'--repo={self.repository_location}', 'create', 'foo-2015-08-12-20:00', src_dir)
         self.cmd(f'--repo={self.repository_location}', 'create', 'bar-2015-08-12-10:00', src_dir)
         self.cmd(f'--repo={self.repository_location}', 'create', 'bar-2015-08-12-20:00', src_dir)
-        output = self.cmd(f'--repo={self.repository_location}', 'prune', '--list', '--dry-run', '--keep-daily=1', '--prefix=foo-')
+        output = self.cmd(f'--repo={self.repository_location}', 'prune', '--list', '--dry-run', '--keep-daily=1', '--glob-archives=foo-*')
         assert re.search(r'Keeping archive \(rule: daily #1\):\s+foo-2015-08-12-20:00', output)
         assert re.search(r'Would prune:\s+foo-2015-08-12-10:00', output)
         output = self.cmd(f'--repo={self.repository_location}', 'rlist')
@@ -2267,7 +2267,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self.assert_in('foo-2015-08-12-20:00', output)
         self.assert_in('bar-2015-08-12-10:00', output)
         self.assert_in('bar-2015-08-12-20:00', output)
-        self.cmd(f'--repo={self.repository_location}', 'prune', '--keep-daily=1', '--prefix=foo-')
+        self.cmd(f'--repo={self.repository_location}', 'prune', '--keep-daily=1', '--glob-archives=foo-*')
         output = self.cmd(f'--repo={self.repository_location}', 'rlist')
         self.assert_not_in('foo-2015-08-12-10:00', output)
         self.assert_in('foo-2015-08-12-20:00', output)
@@ -2300,7 +2300,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         self.cmd(f'--repo={self.repository_location}', 'create', 'test-1', src_dir)
         self.cmd(f'--repo={self.repository_location}', 'create', 'something-else-than-test-1', src_dir)
         self.cmd(f'--repo={self.repository_location}', 'create', 'test-2', src_dir)
-        output = self.cmd(f'--repo={self.repository_location}', 'rlist', '--prefix=test-')
+        output = self.cmd(f'--repo={self.repository_location}', 'rlist', '--glob-archives=test-*')
         self.assert_in('test-1', output)
         self.assert_in('test-2', output)
         self.assert_not_in('something-else', output)
@@ -2664,13 +2664,13 @@ class ArchiverTestCase(ArchiverTestCaseBase):
             assert sorted(os.listdir(os.path.join(mountpoint))) == ['arch11', 'arch12']
         with self.fuse_mount(self.repository_location, mountpoint, '--last=2', '--sort=name'):
             assert sorted(os.listdir(os.path.join(mountpoint))) == ['arch21', 'arch22']
-        with self.fuse_mount(self.repository_location, mountpoint, '--prefix=arch1'):
+        with self.fuse_mount(self.repository_location, mountpoint, '--glob-archives=arch1*'):
             assert sorted(os.listdir(os.path.join(mountpoint))) == ['arch11', 'arch12']
-        with self.fuse_mount(self.repository_location, mountpoint, '--prefix=arch2'):
+        with self.fuse_mount(self.repository_location, mountpoint, '--glob-archives=arch2*'):
             assert sorted(os.listdir(os.path.join(mountpoint))) == ['arch21', 'arch22']
-        with self.fuse_mount(self.repository_location, mountpoint, '--prefix=arch'):
+        with self.fuse_mount(self.repository_location, mountpoint, '--glob-archives=arch*'):
             assert sorted(os.listdir(os.path.join(mountpoint))) == ['arch11', 'arch12', 'arch21', 'arch22']
-        with self.fuse_mount(self.repository_location, mountpoint, '--prefix=nope'):
+        with self.fuse_mount(self.repository_location, mountpoint, '--glob-archives=nope'):
             assert sorted(os.listdir(os.path.join(mountpoint))) == []
 
     @unittest.skipUnless(llfuse, 'llfuse not installed')
@@ -3559,7 +3559,7 @@ class ArchiverCheckTestCase(ArchiverTestCaseBase):
         output = self.cmd(f'--repo={self.repository_location}', 'check', '-v', '--archives-only', exit_code=0)
         self.assert_not_in('Starting repository check', output)
         self.assert_in('Starting archive consistency check', output)
-        output = self.cmd(f'--repo={self.repository_location}', 'check', '-v', '--archives-only', '--prefix=archive2', exit_code=0)
+        output = self.cmd(f'--repo={self.repository_location}', 'check', '-v', '--archives-only', '--glob-archives=archive2', exit_code=0)
         self.assert_not_in('archive1', output)
         output = self.cmd(f'--repo={self.repository_location}', 'check', '-v', '--archives-only', '--first=1', exit_code=0)
         self.assert_in('archive1', output)

From d8735450c5812d91e48d0ea32ec6c79753362d35 Mon Sep 17 00:00:00 2001
From: Thomas Waldmann <tw@waldmann-edv.de>
Date: Sat, 2 Jul 2022 21:55:45 +0200
Subject: [PATCH 095/160] remove deprecated --noatime

not storing atime is the default since 1.2.
--noatime is deprecated since 1.2.

there is --atime if you want to store the atime.
---
 src/borg/archiver.py | 5 -----
 1 file changed, 5 deletions(-)

diff --git a/src/borg/archiver.py b/src/borg/archiver.py
index 3d2885d3f..59ca92803 100644
--- a/src/borg/archiver.py
+++ b/src/borg/archiver.py
@@ -2833,7 +2833,6 @@ class Archiver:
     def preprocess_args(self, args):
         deprecations = [
             # ('--old', '--new' or None, 'Warning: "--old" has been deprecated. Use "--new" instead.'),
-            ('--noatime', None, 'Warning: "--noatime" has been deprecated because it is the default now.'),
             ('--nobsdflags', None, 'Warning: "--nobsdflags" has been deprecated. Use --noflags instead.'),
             ('--numeric-owner', None, 'Warning: "--numeric-owner" has been deprecated. Use --numeric-ids instead.'),
             ('--remote-ratelimit', None, 'Warning: "--remote-ratelimit" has been deprecated. Use --upload-ratelimit instead.'),
@@ -3707,10 +3706,6 @@ class Archiver:
                               help='deprecated, use ``--numeric-ids`` instead')
         fs_group.add_argument('--numeric-ids', dest='numeric_ids', action='store_true',
                               help='only store numeric user and group identifiers')
-        # --noatime is the default now and the flag is deprecated. args.noatime is not used any more.
-        # use --atime if you want to store the atime (default behaviour before borg 1.2.0a7)..
-        fs_group.add_argument('--noatime', dest='noatime', action='store_true',
-                              help='do not store atime into archive')
         fs_group.add_argument('--atime', dest='atime', action='store_true',
                               help='do store atime into archive')
         fs_group.add_argument('--noctime', dest='noctime', action='store_true',

From 1196d14f454c4e9d773a3573c1adb374f6131197 Mon Sep 17 00:00:00 2001
From: Thomas Waldmann <tw@waldmann-edv.de>
Date: Sat, 2 Jul 2022 22:00:13 +0200
Subject: [PATCH 096/160] remove deprecated --nobsdflags

--nobsdflags is deprecated since 1.2.

there is --flags for the same purpose.
---
 src/borg/archiver.py | 9 ++-------
 1 file changed, 2 insertions(+), 7 deletions(-)

diff --git a/src/borg/archiver.py b/src/borg/archiver.py
index 59ca92803..1df96489f 100644
--- a/src/borg/archiver.py
+++ b/src/borg/archiver.py
@@ -941,7 +941,7 @@ class Archiver:
 
         self.output_filter = args.output_filter
         self.output_list = args.output_list
-        self.noflags = args.nobsdflags or args.noflags
+        self.noflags = args.noflags
         self.noacls = args.noacls
         self.noxattrs = args.noxattrs
         self.exclude_nodump = args.exclude_nodump
@@ -960,7 +960,7 @@ class Archiver:
                                   chunker_params=args.chunker_params, start=t0, start_monotonic=t0_monotonic,
                                   log_json=args.log_json, iec=args.iec)
                 metadata_collector = MetadataCollector(noatime=not args.atime, noctime=args.noctime,
-                    noflags=args.nobsdflags or args.noflags, noacls=args.noacls, noxattrs=args.noxattrs,
+                    noflags=args.noflags, noacls=args.noacls, noxattrs=args.noxattrs,
                     numeric_ids=args.numeric_ids, nobirthtime=args.nobirthtime)
                 cp = ChunksProcessor(cache=cache, key=key,
                     add_item=archive.add_item, write_checkpoint=archive.write_checkpoint,
@@ -2833,7 +2833,6 @@ class Archiver:
     def preprocess_args(self, args):
         deprecations = [
             # ('--old', '--new' or None, 'Warning: "--old" has been deprecated. Use "--new" instead.'),
-            ('--nobsdflags', None, 'Warning: "--nobsdflags" has been deprecated. Use --noflags instead.'),
             ('--numeric-owner', None, 'Warning: "--numeric-owner" has been deprecated. Use --numeric-ids instead.'),
             ('--remote-ratelimit', None, 'Warning: "--remote-ratelimit" has been deprecated. Use --upload-ratelimit instead.'),
             ('--remote-buffer', None, 'Warning: "--remote-buffer" has been deprecated. Use --upload-buffer instead.'),
@@ -3712,8 +3711,6 @@ class Archiver:
                               help='do not store ctime into archive')
         fs_group.add_argument('--nobirthtime', dest='nobirthtime', action='store_true',
                               help='do not store birthtime (creation date) into archive')
-        fs_group.add_argument('--nobsdflags', dest='nobsdflags', action='store_true',
-                              help='deprecated, use ``--noflags`` instead')
         fs_group.add_argument('--noflags', dest='noflags', action='store_true',
                               help='do not read and store flags (e.g. NODUMP, IMMUTABLE) into archive')
         fs_group.add_argument('--noacls', dest='noacls', action='store_true',
@@ -4193,8 +4190,6 @@ class Archiver:
                                help='deprecated, use ``--numeric-ids`` instead')
         subparser.add_argument('--numeric-ids', dest='numeric_ids', action='store_true',
                                help='only obey numeric user and group identifiers')
-        subparser.add_argument('--nobsdflags', dest='nobsdflags', action='store_true',
-                               help='deprecated, use ``--noflags`` instead')
         subparser.add_argument('--noflags', dest='noflags', action='store_true',
                                help='do not extract/set flags (e.g. NODUMP, IMMUTABLE)')
         subparser.add_argument('--noacls', dest='noacls', action='store_true',

From 79696429b4861cfa08ad2c300209ba43196914a7 Mon Sep 17 00:00:00 2001
From: Thomas Waldmann <tw@waldmann-edv.de>
Date: Sat, 2 Jul 2022 22:05:47 +0200
Subject: [PATCH 097/160] remove deprecated --numeric-owner

--numeric-owner is deprecated since 1.2.

there is --numeric-ids for the same purpose.
---
 src/borg/archiver.py | 9 ---------
 1 file changed, 9 deletions(-)

diff --git a/src/borg/archiver.py b/src/borg/archiver.py
index 1df96489f..2b4801b3c 100644
--- a/src/borg/archiver.py
+++ b/src/borg/archiver.py
@@ -2833,7 +2833,6 @@ class Archiver:
     def preprocess_args(self, args):
         deprecations = [
             # ('--old', '--new' or None, 'Warning: "--old" has been deprecated. Use "--new" instead.'),
-            ('--numeric-owner', None, 'Warning: "--numeric-owner" has been deprecated. Use --numeric-ids instead.'),
             ('--remote-ratelimit', None, 'Warning: "--remote-ratelimit" has been deprecated. Use --upload-ratelimit instead.'),
             ('--remote-buffer', None, 'Warning: "--remote-buffer" has been deprecated. Use --upload-buffer instead.'),
         ]
@@ -3126,8 +3125,6 @@ class Archiver:
                                 help='stay in foreground, do not daemonize')
             parser.add_argument('-o', dest='options', type=str, action=Highlander,
                                 help='Extra mount options')
-            parser.add_argument('--numeric-owner', dest='numeric_ids', action='store_true',
-                                  help='deprecated, use ``--numeric-ids`` instead')
             parser.add_argument('--numeric-ids', dest='numeric_ids', action='store_true',
                                   help='use numeric user and group identifiers from archive(s)')
             define_archive_filters_group(parser)
@@ -3701,8 +3698,6 @@ class Archiver:
         fs_group = subparser.add_argument_group('Filesystem options')
         fs_group.add_argument('-x', '--one-file-system', dest='one_file_system', action='store_true',
                               help='stay in the same file system and do not store mount points of other file systems.  This might behave different from your expectations, see the docs.')
-        fs_group.add_argument('--numeric-owner', dest='numeric_ids', action='store_true',
-                              help='deprecated, use ``--numeric-ids`` instead')
         fs_group.add_argument('--numeric-ids', dest='numeric_ids', action='store_true',
                               help='only store numeric user and group identifiers')
         fs_group.add_argument('--atime', dest='atime', action='store_true',
@@ -4066,8 +4061,6 @@ class Archiver:
                                           formatter_class=argparse.RawDescriptionHelpFormatter,
                                           help='find differences in archive contents')
         subparser.set_defaults(func=self.do_diff)
-        subparser.add_argument('--numeric-owner', dest='numeric_ids', action='store_true',
-                               help='deprecated, use ``--numeric-ids`` instead')
         subparser.add_argument('--numeric-ids', dest='numeric_ids', action='store_true',
                                help='only consider numeric user and group identifiers')
         subparser.add_argument('--same-chunker-params', dest='same_chunker_params', action='store_true',
@@ -4186,8 +4179,6 @@ class Archiver:
                                help='output verbose list of items (files, dirs, ...)')
         subparser.add_argument('-n', '--dry-run', dest='dry_run', action='store_true',
                                help='do not actually change any files')
-        subparser.add_argument('--numeric-owner', dest='numeric_ids', action='store_true',
-                               help='deprecated, use ``--numeric-ids`` instead')
         subparser.add_argument('--numeric-ids', dest='numeric_ids', action='store_true',
                                help='only obey numeric user and group identifiers')
         subparser.add_argument('--noflags', dest='noflags', action='store_true',

From 1b88eb67e09870ae8043b42a9e6c5c0a62352fc2 Mon Sep 17 00:00:00 2001
From: Thomas Waldmann <tw@waldmann-edv.de>
Date: Sat, 2 Jul 2022 22:08:19 +0200
Subject: [PATCH 098/160] remove deprecated --remote-ratelimit

--remote-ratelimit is deprecated since 1.2.

there is --upload-ratelimit for the same purpose.
---
 src/borg/archiver.py | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/src/borg/archiver.py b/src/borg/archiver.py
index 2b4801b3c..13801300f 100644
--- a/src/borg/archiver.py
+++ b/src/borg/archiver.py
@@ -2833,7 +2833,6 @@ class Archiver:
     def preprocess_args(self, args):
         deprecations = [
             # ('--old', '--new' or None, 'Warning: "--old" has been deprecated. Use "--new" instead.'),
-            ('--remote-ratelimit', None, 'Warning: "--remote-ratelimit" has been deprecated. Use --upload-ratelimit instead.'),
             ('--remote-buffer', None, 'Warning: "--remote-buffer" has been deprecated. Use --upload-buffer instead.'),
         ]
         for i, arg in enumerate(args[:]):
@@ -3036,8 +3035,6 @@ class Archiver:
                               help='set umask to M (local only, default: %(default)04o)')
             add_common_option('--remote-path', metavar='PATH', dest='remote_path',
                               help='use PATH as borg executable on the remote (default: "borg")')
-            add_common_option('--remote-ratelimit', metavar='RATE', dest='upload_ratelimit', type=int,
-                              help='deprecated, use ``--upload-ratelimit`` instead')
             add_common_option('--upload-ratelimit', metavar='RATE', dest='upload_ratelimit', type=int,
                               help='set network upload rate limit in kiByte/s (default: 0=unlimited)')
             add_common_option('--remote-buffer', metavar='UPLOAD_BUFFER', dest='upload_buffer', type=int,

From 0dac106812785abcb6688cbda6e48a915c8adeb1 Mon Sep 17 00:00:00 2001
From: Thomas Waldmann <tw@waldmann-edv.de>
Date: Sat, 2 Jul 2022 22:09:55 +0200
Subject: [PATCH 099/160] remove deprecated --remote-buffer

--remote-buffer is deprecated since 1.2.

there is --upload-buffer for the same purpose.
---
 src/borg/archiver.py | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/src/borg/archiver.py b/src/borg/archiver.py
index 13801300f..17cf970ca 100644
--- a/src/borg/archiver.py
+++ b/src/borg/archiver.py
@@ -2833,7 +2833,6 @@ class Archiver:
     def preprocess_args(self, args):
         deprecations = [
             # ('--old', '--new' or None, 'Warning: "--old" has been deprecated. Use "--new" instead.'),
-            ('--remote-buffer', None, 'Warning: "--remote-buffer" has been deprecated. Use --upload-buffer instead.'),
         ]
         for i, arg in enumerate(args[:]):
             for old_name, new_name, warning in deprecations:
@@ -3037,8 +3036,6 @@ class Archiver:
                               help='use PATH as borg executable on the remote (default: "borg")')
             add_common_option('--upload-ratelimit', metavar='RATE', dest='upload_ratelimit', type=int,
                               help='set network upload rate limit in kiByte/s (default: 0=unlimited)')
-            add_common_option('--remote-buffer', metavar='UPLOAD_BUFFER', dest='upload_buffer', type=int,
-                              help='deprecated, use ``--upload-buffer`` instead')
             add_common_option('--upload-buffer', metavar='UPLOAD_BUFFER', dest='upload_buffer', type=int,
                               help='set network upload buffer size in MiB. (default: 0=no buffer)')
             add_common_option('--consider-part-files', dest='consider_part_files', action='store_true',

From 907ffbecfaa03cdedf74d11550f170525172875f Mon Sep 17 00:00:00 2001
From: Thomas Waldmann <tw@waldmann-edv.de>
Date: Mon, 4 Jul 2022 01:15:58 +0200
Subject: [PATCH 100/160] update CHANGES

---
 docs/changes.rst | 35 ++++++++++++++++++++++++++++++++++-
 1 file changed, 34 insertions(+), 1 deletion(-)

diff --git a/docs/changes.rst b/docs/changes.rst
index 4073ee83c..2a33bdada 100644
--- a/docs/changes.rst
+++ b/docs/changes.rst
@@ -12,7 +12,7 @@ This section provides information about security and corruption issues.
 Change Log 2.x
 ==============
 
-Version 2.0.0a2 (2022-06-26)
+Version 2.0.0a3 (2022-07-04)
 ----------------------------
 
 Please note:
@@ -38,6 +38,7 @@ Compatibility notes:
     call borg like: "borg -r <MYREPO> <COMMAND>".
     in the docs, we usually omit "-r ..." for brevity.
   - the scp-style REPO syntax was removed, please use ssh://..., #6697
+  - -P / --prefix option was removed, please use the similar -a / --glob-archives.
   - differently than with borg 1.x you ONLY give the repo there, never a ::archive.
   - the archive name is either given as a positional parameter, like:
 
@@ -70,6 +71,38 @@ Compatibility notes:
       - borg mount -a ARCH_GLOB mountpoint ...
 
     For more details, please consult the docs or --help option output.
+- some deprecated options were removed:
+
+  - removed --remote-ratelimit (use --upload-ratelimit)
+  - removed --numeric-owner (use --numeric-ids)
+  - removed --nobsdflags (use --noflags)
+  - removed --noatime (default now, see also --atime)
+
+Fixes:
+
+- check repo version, accept old repos only for --other-repo (e.g. rcreate/transfer).
+  v2 is the default repo version for borg 2.0. v1 repos must only be used in a
+  read-only way, e.g. for --other-repo=V1_REPO with borg init and borg transfer!
+
+New features:
+
+- transfer: --upgrader=NoOp is the default.
+  This is to support general-purpose transfer of archives between related borg2
+  repos.
+- transfer: --upgrader=From12To20 must be used to transfer (and convert) archives
+  from borg 1.2 repos to borg 2.0 repos.
+
+Other changes:
+
+- removed some deprecated options
+- removed -P (aka --prefix) option, #6806. The option -a (aka --glob-archives)
+  can be used for same purpose and is more powerful, e.g.: -a 'PREFIX*'
+- rcreate: always use argon2 kdf for new repos, #6820
+- rcreate: remove legacy encryption modes for new repos, #6490
+
+
+Version 2.0.0a2 (2022-06-26)
+----------------------------
 
 Changes:
 

From 6fa8d11ecc92e3010b3aa30352469d57fb03ce9d Mon Sep 17 00:00:00 2001
From: Thomas Waldmann <tw@waldmann-edv.de>
Date: Mon, 4 Jul 2022 01:21:50 +0200
Subject: [PATCH 101/160] build_usage ; build_man

---
 docs/man/borg-benchmark-cpu.1         |   2 +-
 docs/man/borg-benchmark-crud.1        |   2 +-
 docs/man/borg-benchmark.1             |   2 +-
 docs/man/borg-break-lock.1            |   2 +-
 docs/man/borg-check.1                 |   7 +-
 docs/man/borg-common.1                |   8 +-
 docs/man/borg-compact.1               |   2 +-
 docs/man/borg-compression.1           |   2 +-
 docs/man/borg-config.1                |   2 +-
 docs/man/borg-create.1                |  11 +--
 docs/man/borg-delete.1                |  17 ++---
 docs/man/borg-diff.1                  |   5 +-
 docs/man/borg-export-tar.1            |   2 +-
 docs/man/borg-extract.1               |   8 +-
 docs/man/borg-import-tar.1            |   2 +-
 docs/man/borg-info.1                  |   7 +-
 docs/man/borg-key-change-location.1   |   2 +-
 docs/man/borg-key-change-passphrase.1 |   2 +-
 docs/man/borg-key-export.1            |   2 +-
 docs/man/borg-key-import.1            |   2 +-
 docs/man/borg-key.1                   |   5 +-
 docs/man/borg-list.1                  |   2 +-
 docs/man/borg-mount.1                 |  21 +++---
 docs/man/borg-patterns.1              |   2 +-
 docs/man/borg-placeholders.1          |   6 +-
 docs/man/borg-prune.1                 |  13 ++--
 docs/man/borg-rcreate.1               |  24 +-----
 docs/man/borg-rdelete.1               |   2 +-
 docs/man/borg-recreate.1              |   7 +-
 docs/man/borg-rename.1                |   2 +-
 docs/man/borg-rinfo.1                 |   2 +-
 docs/man/borg-rlist.1                 |   7 +-
 docs/man/borg-serve.1                 |   2 +-
 docs/man/borg-transfer.1              |  28 +++++--
 docs/man/borg-umount.1                |   2 +-
 docs/man/borg-with-lock.1             |   2 +-
 docs/man/borg.1                       |   2 +-
 docs/man/borgfs.1                     |  21 +++---
 docs/usage/check.rst.inc              |  63 ++++++++--------
 docs/usage/common-options.rst.inc     |   2 -
 docs/usage/create.rst.inc             |   9 ---
 docs/usage/delete.rst.inc             |  79 +++++++++----------
 docs/usage/diff.rst.inc               |   3 -
 docs/usage/extract.rst.inc            |   6 --
 docs/usage/help.rst.inc               |   4 +-
 docs/usage/info.rst.inc               |  43 +++++------
 docs/usage/mount.rst.inc              | 105 +++++++++++++-------------
 docs/usage/prune.rst.inc              |  79 ++++++++++---------
 docs/usage/rcreate.rst.inc            |  20 -----
 docs/usage/recreate.rst.inc           |   7 +-
 docs/usage/rlist.rst.inc              |   7 +-
 docs/usage/transfer.rst.inc           |  61 ++++++++-------
 52 files changed, 306 insertions(+), 421 deletions(-)

diff --git a/docs/man/borg-benchmark-cpu.1 b/docs/man/borg-benchmark-cpu.1
index ebafe2611..ada06605c 100644
--- a/docs/man/borg-benchmark-cpu.1
+++ b/docs/man/borg-benchmark-cpu.1
@@ -27,7 +27,7 @@ level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .in \\n[rst2man-indent\\n[rst2man-indent-level]]u
 ..
-.TH "BORG-BENCHMARK-CPU" 1 "2022-06-26" "" "borg backup tool"
+.TH "BORG-BENCHMARK-CPU" 1 "2022-07-03" "" "borg backup tool"
 .SH NAME
 borg-benchmark-cpu \- Benchmark CPU bound operations.
 .SH SYNOPSIS
diff --git a/docs/man/borg-benchmark-crud.1 b/docs/man/borg-benchmark-crud.1
index 0dc00b27a..7dfc60ac5 100644
--- a/docs/man/borg-benchmark-crud.1
+++ b/docs/man/borg-benchmark-crud.1
@@ -27,7 +27,7 @@ level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .in \\n[rst2man-indent\\n[rst2man-indent-level]]u
 ..
-.TH "BORG-BENCHMARK-CRUD" 1 "2022-06-26" "" "borg backup tool"
+.TH "BORG-BENCHMARK-CRUD" 1 "2022-07-03" "" "borg backup tool"
 .SH NAME
 borg-benchmark-crud \- Benchmark Create, Read, Update, Delete for archives.
 .SH SYNOPSIS
diff --git a/docs/man/borg-benchmark.1 b/docs/man/borg-benchmark.1
index 405c96248..97102ec3a 100644
--- a/docs/man/borg-benchmark.1
+++ b/docs/man/borg-benchmark.1
@@ -27,7 +27,7 @@ level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .in \\n[rst2man-indent\\n[rst2man-indent-level]]u
 ..
-.TH "BORG-BENCHMARK" 1 "2022-06-26" "" "borg backup tool"
+.TH "BORG-BENCHMARK" 1 "2022-07-03" "" "borg backup tool"
 .SH NAME
 borg-benchmark \- benchmark command
 .SH SYNOPSIS
diff --git a/docs/man/borg-break-lock.1 b/docs/man/borg-break-lock.1
index 2332c86ad..5af44e937 100644
--- a/docs/man/borg-break-lock.1
+++ b/docs/man/borg-break-lock.1
@@ -27,7 +27,7 @@ level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .in \\n[rst2man-indent\\n[rst2man-indent-level]]u
 ..
-.TH "BORG-BREAK-LOCK" 1 "2022-06-26" "" "borg backup tool"
+.TH "BORG-BREAK-LOCK" 1 "2022-07-03" "" "borg backup tool"
 .SH NAME
 borg-break-lock \- Break the repository lock (e.g. in case it was left by a dead borg.
 .SH SYNOPSIS
diff --git a/docs/man/borg-check.1 b/docs/man/borg-check.1
index 6f2835d2d..a070031c9 100644
--- a/docs/man/borg-check.1
+++ b/docs/man/borg-check.1
@@ -27,7 +27,7 @@ level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .in \\n[rst2man-indent\\n[rst2man-indent-level]]u
 ..
-.TH "BORG-CHECK" 1 "2022-06-26" "" "borg backup tool"
+.TH "BORG-CHECK" 1 "2022-07-03" "" "borg backup tool"
 .SH NAME
 borg-check \- Check repository consistency
 .SH SYNOPSIS
@@ -150,11 +150,8 @@ do only a partial repo check for max. SECONDS seconds (Default: unlimited)
 .SS Archive filters
 .INDENT 0.0
 .TP
-.BI \-P \ PREFIX\fR,\fB \ \-\-prefix \ PREFIX
-only consider archive names starting with this prefix.
-.TP
 .BI \-a \ GLOB\fR,\fB \ \-\-glob\-archives \ GLOB
-only consider archive names matching the glob. sh: rules apply, see "borg help patterns". \fB\-\-prefix\fP and \fB\-\-glob\-archives\fP are mutually exclusive.
+only consider archive names matching the glob. sh: rules apply, see "borg help patterns".
 .TP
 .BI \-\-sort\-by \ KEYS
 Comma\-separated list of sorting keys; valid keys are: timestamp, name, id; default is: timestamp
diff --git a/docs/man/borg-common.1 b/docs/man/borg-common.1
index c702af4fe..80512171a 100644
--- a/docs/man/borg-common.1
+++ b/docs/man/borg-common.1
@@ -27,7 +27,7 @@ level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .in \\n[rst2man-indent\\n[rst2man-indent-level]]u
 ..
-.TH "BORG-COMMON" 1 "2022-06-26" "" "borg backup tool"
+.TH "BORG-COMMON" 1 "2022-07-03" "" "borg backup tool"
 .SH NAME
 borg-common \- Common options of Borg commands
 .SH SYNOPSIS
@@ -81,15 +81,9 @@ set umask to M (local only, default: 0077)
 .BI \-\-remote\-path \ PATH
 use PATH as borg executable on the remote (default: "borg")
 .TP
-.BI \-\-remote\-ratelimit \ RATE
-deprecated, use \fB\-\-upload\-ratelimit\fP instead
-.TP
 .BI \-\-upload\-ratelimit \ RATE
 set network upload rate limit in kiByte/s (default: 0=unlimited)
 .TP
-.BI \-\-remote\-buffer \ UPLOAD_BUFFER
-deprecated, use \fB\-\-upload\-buffer\fP instead
-.TP
 .BI \-\-upload\-buffer \ UPLOAD_BUFFER
 set network upload buffer size in MiB. (default: 0=no buffer)
 .TP
diff --git a/docs/man/borg-compact.1 b/docs/man/borg-compact.1
index 03e64ba14..a440b8c8d 100644
--- a/docs/man/borg-compact.1
+++ b/docs/man/borg-compact.1
@@ -27,7 +27,7 @@ level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .in \\n[rst2man-indent\\n[rst2man-indent-level]]u
 ..
-.TH "BORG-COMPACT" 1 "2022-06-26" "" "borg backup tool"
+.TH "BORG-COMPACT" 1 "2022-07-03" "" "borg backup tool"
 .SH NAME
 borg-compact \- compact segment files in the repository
 .SH SYNOPSIS
diff --git a/docs/man/borg-compression.1 b/docs/man/borg-compression.1
index 52c16fec6..7991b8ea8 100644
--- a/docs/man/borg-compression.1
+++ b/docs/man/borg-compression.1
@@ -27,7 +27,7 @@ level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .in \\n[rst2man-indent\\n[rst2man-indent-level]]u
 ..
-.TH "BORG-COMPRESSION" 1 "2022-06-26" "" "borg backup tool"
+.TH "BORG-COMPRESSION" 1 "2022-07-03" "" "borg backup tool"
 .SH NAME
 borg-compression \- Details regarding compression
 .SH DESCRIPTION
diff --git a/docs/man/borg-config.1 b/docs/man/borg-config.1
index 6aa66f922..27a263ac5 100644
--- a/docs/man/borg-config.1
+++ b/docs/man/borg-config.1
@@ -27,7 +27,7 @@ level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .in \\n[rst2man-indent\\n[rst2man-indent-level]]u
 ..
-.TH "BORG-CONFIG" 1 "2022-06-26" "" "borg backup tool"
+.TH "BORG-CONFIG" 1 "2022-07-03" "" "borg backup tool"
 .SH NAME
 borg-config \- get, set, and delete values in a repository or cache config file
 .SH SYNOPSIS
diff --git a/docs/man/borg-create.1 b/docs/man/borg-create.1
index 7c1509ace..c27aad5c7 100644
--- a/docs/man/borg-create.1
+++ b/docs/man/borg-create.1
@@ -27,7 +27,7 @@ level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .in \\n[rst2man-indent\\n[rst2man-indent-level]]u
 ..
-.TH "BORG-CREATE" 1 "2022-06-26" "" "borg backup tool"
+.TH "BORG-CREATE" 1 "2022-07-03" "" "borg backup tool"
 .SH NAME
 borg-create \- Create new archive
 .SH SYNOPSIS
@@ -210,15 +210,9 @@ exclude files flagged NODUMP
 .B  \-x\fP,\fB  \-\-one\-file\-system
 stay in the same file system and do not store mount points of other file systems.  This might behave different from your expectations, see the docs.
 .TP
-.B  \-\-numeric\-owner
-deprecated, use \fB\-\-numeric\-ids\fP instead
-.TP
 .B  \-\-numeric\-ids
 only store numeric user and group identifiers
 .TP
-.B  \-\-noatime
-do not store atime into archive
-.TP
 .B  \-\-atime
 do store atime into archive
 .TP
@@ -228,9 +222,6 @@ do not store ctime into archive
 .B  \-\-nobirthtime
 do not store birthtime (creation date) into archive
 .TP
-.B  \-\-nobsdflags
-deprecated, use \fB\-\-noflags\fP instead
-.TP
 .B  \-\-noflags
 do not read and store flags (e.g. NODUMP, IMMUTABLE) into archive
 .TP
diff --git a/docs/man/borg-delete.1 b/docs/man/borg-delete.1
index 7f1e4b05d..ace74bd86 100644
--- a/docs/man/borg-delete.1
+++ b/docs/man/borg-delete.1
@@ -27,7 +27,7 @@ level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .in \\n[rst2man-indent\\n[rst2man-indent-level]]u
 ..
-.TH "BORG-DELETE" 1 "2022-06-26" "" "borg backup tool"
+.TH "BORG-DELETE" 1 "2022-07-03" "" "borg backup tool"
 .SH NAME
 borg-delete \- Delete archives
 .SH SYNOPSIS
@@ -47,11 +47,9 @@ deleted \- the "Deleted data" deduplicated size there is most interesting as
 that is how much your repository will shrink.
 Please note that the "All archives" stats refer to the state after deletion.
 .sp
-You can delete multiple archives by specifying their common prefix, if they
-have one, using the \fB\-\-prefix PREFIX\fP option. You can also specify a shell
-pattern to match multiple archives using the \fB\-\-glob\-archives GLOB\fP option
-(for more info on these patterns, see \fIborg_patterns\fP). Note that these
-two options are mutually exclusive.
+You can delete multiple archives by specifying a matching shell pattern,
+using the \fB\-\-glob\-archives GLOB\fP option (for more info on these patterns,
+see \fIborg_patterns\fP).
 .sp
 Always first use \fB\-\-dry\-run \-\-list\fP to see what would be deleted.
 .SH OPTIONS
@@ -87,11 +85,8 @@ work slower, but using less space
 .SS Archive filters
 .INDENT 0.0
 .TP
-.BI \-P \ PREFIX\fR,\fB \ \-\-prefix \ PREFIX
-only consider archive names starting with this prefix.
-.TP
 .BI \-a \ GLOB\fR,\fB \ \-\-glob\-archives \ GLOB
-only consider archive names matching the glob. sh: rules apply, see "borg help patterns". \fB\-\-prefix\fP and \fB\-\-glob\-archives\fP are mutually exclusive.
+only consider archive names matching the glob. sh: rules apply, see "borg help patterns".
 .TP
 .BI \-\-sort\-by \ KEYS
 Comma\-separated list of sorting keys; valid keys are: timestamp, name, id; default is: timestamp
@@ -114,7 +109,7 @@ $ borg delete Monday
 $ borg compact
 
 # delete all archives whose names begin with the machine\(aqs hostname followed by "\-"
-$ borg delete \-\-prefix \(aq{hostname}\-\(aq
+$ borg delete \-a \(aq{hostname}\-*\(aq
 
 # delete all archives whose names contain "\-2012\-"
 $ borg delete \-a \(aq*\-2012\-*\(aq
diff --git a/docs/man/borg-diff.1 b/docs/man/borg-diff.1
index 5f67f8746..f89e05735 100644
--- a/docs/man/borg-diff.1
+++ b/docs/man/borg-diff.1
@@ -27,7 +27,7 @@ level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .in \\n[rst2man-indent\\n[rst2man-indent-level]]u
 ..
-.TH "BORG-DIFF" 1 "2022-06-26" "" "borg backup tool"
+.TH "BORG-DIFF" 1 "2022-07-03" "" "borg backup tool"
 .SH NAME
 borg-diff \- Diff contents of two archives
 .SH SYNOPSIS
@@ -69,9 +69,6 @@ paths of items inside the archives to compare; patterns are supported
 .SS optional arguments
 .INDENT 0.0
 .TP
-.B  \-\-numeric\-owner
-deprecated, use \fB\-\-numeric\-ids\fP instead
-.TP
 .B  \-\-numeric\-ids
 only consider numeric user and group identifiers
 .TP
diff --git a/docs/man/borg-export-tar.1 b/docs/man/borg-export-tar.1
index 609698d7f..2d49b41ef 100644
--- a/docs/man/borg-export-tar.1
+++ b/docs/man/borg-export-tar.1
@@ -27,7 +27,7 @@ level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .in \\n[rst2man-indent\\n[rst2man-indent-level]]u
 ..
-.TH "BORG-EXPORT-TAR" 1 "2022-06-26" "" "borg backup tool"
+.TH "BORG-EXPORT-TAR" 1 "2022-07-03" "" "borg backup tool"
 .SH NAME
 borg-export-tar \- Export archive contents as a tarball
 .SH SYNOPSIS
diff --git a/docs/man/borg-extract.1 b/docs/man/borg-extract.1
index a8fd1125b..274087534 100644
--- a/docs/man/borg-extract.1
+++ b/docs/man/borg-extract.1
@@ -27,7 +27,7 @@ level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .in \\n[rst2man-indent\\n[rst2man-indent-level]]u
 ..
-.TH "BORG-EXTRACT" 1 "2022-06-26" "" "borg backup tool"
+.TH "BORG-EXTRACT" 1 "2022-07-03" "" "borg backup tool"
 .SH NAME
 borg-extract \- Extract archive contents
 .SH SYNOPSIS
@@ -81,15 +81,9 @@ output verbose list of items (files, dirs, ...)
 .B  \-n\fP,\fB  \-\-dry\-run
 do not actually change any files
 .TP
-.B  \-\-numeric\-owner
-deprecated, use \fB\-\-numeric\-ids\fP instead
-.TP
 .B  \-\-numeric\-ids
 only obey numeric user and group identifiers
 .TP
-.B  \-\-nobsdflags
-deprecated, use \fB\-\-noflags\fP instead
-.TP
 .B  \-\-noflags
 do not extract/set flags (e.g. NODUMP, IMMUTABLE)
 .TP
diff --git a/docs/man/borg-import-tar.1 b/docs/man/borg-import-tar.1
index fc7e37a92..568b12149 100644
--- a/docs/man/borg-import-tar.1
+++ b/docs/man/borg-import-tar.1
@@ -27,7 +27,7 @@ level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .in \\n[rst2man-indent\\n[rst2man-indent-level]]u
 ..
-.TH "BORG-IMPORT-TAR" 1 "2022-06-26" "" "borg backup tool"
+.TH "BORG-IMPORT-TAR" 1 "2022-07-03" "" "borg backup tool"
 .SH NAME
 borg-import-tar \- Create a backup archive from a tarball
 .SH SYNOPSIS
diff --git a/docs/man/borg-info.1 b/docs/man/borg-info.1
index 0daa2ce6c..c32b057ea 100644
--- a/docs/man/borg-info.1
+++ b/docs/man/borg-info.1
@@ -27,7 +27,7 @@ level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .in \\n[rst2man-indent\\n[rst2man-indent-level]]u
 ..
-.TH "BORG-INFO" 1 "2022-06-26" "" "borg backup tool"
+.TH "BORG-INFO" 1 "2022-07-03" "" "borg backup tool"
 .SH NAME
 borg-info \- Show archive details such as disk space used
 .SH SYNOPSIS
@@ -62,11 +62,8 @@ format output as JSON
 .SS Archive filters
 .INDENT 0.0
 .TP
-.BI \-P \ PREFIX\fR,\fB \ \-\-prefix \ PREFIX
-only consider archive names starting with this prefix.
-.TP
 .BI \-a \ GLOB\fR,\fB \ \-\-glob\-archives \ GLOB
-only consider archive names matching the glob. sh: rules apply, see "borg help patterns". \fB\-\-prefix\fP and \fB\-\-glob\-archives\fP are mutually exclusive.
+only consider archive names matching the glob. sh: rules apply, see "borg help patterns".
 .TP
 .BI \-\-sort\-by \ KEYS
 Comma\-separated list of sorting keys; valid keys are: timestamp, name, id; default is: timestamp
diff --git a/docs/man/borg-key-change-location.1 b/docs/man/borg-key-change-location.1
index 417f0d182..87d8873b8 100644
--- a/docs/man/borg-key-change-location.1
+++ b/docs/man/borg-key-change-location.1
@@ -27,7 +27,7 @@ level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .in \\n[rst2man-indent\\n[rst2man-indent-level]]u
 ..
-.TH "BORG-KEY-CHANGE-LOCATION" 1 "2022-06-26" "" "borg backup tool"
+.TH "BORG-KEY-CHANGE-LOCATION" 1 "2022-07-03" "" "borg backup tool"
 .SH NAME
 borg-key-change-location \- Change repository key location
 .SH SYNOPSIS
diff --git a/docs/man/borg-key-change-passphrase.1 b/docs/man/borg-key-change-passphrase.1
index 847c5b300..ba93cbb7c 100644
--- a/docs/man/borg-key-change-passphrase.1
+++ b/docs/man/borg-key-change-passphrase.1
@@ -27,7 +27,7 @@ level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .in \\n[rst2man-indent\\n[rst2man-indent-level]]u
 ..
-.TH "BORG-KEY-CHANGE-PASSPHRASE" 1 "2022-06-26" "" "borg backup tool"
+.TH "BORG-KEY-CHANGE-PASSPHRASE" 1 "2022-07-03" "" "borg backup tool"
 .SH NAME
 borg-key-change-passphrase \- Change repository key file passphrase
 .SH SYNOPSIS
diff --git a/docs/man/borg-key-export.1 b/docs/man/borg-key-export.1
index 55bc248fd..87d37244c 100644
--- a/docs/man/borg-key-export.1
+++ b/docs/man/borg-key-export.1
@@ -27,7 +27,7 @@ level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .in \\n[rst2man-indent\\n[rst2man-indent-level]]u
 ..
-.TH "BORG-KEY-EXPORT" 1 "2022-06-26" "" "borg backup tool"
+.TH "BORG-KEY-EXPORT" 1 "2022-07-03" "" "borg backup tool"
 .SH NAME
 borg-key-export \- Export the repository key for backup
 .SH SYNOPSIS
diff --git a/docs/man/borg-key-import.1 b/docs/man/borg-key-import.1
index d6c190a82..a96de3c22 100644
--- a/docs/man/borg-key-import.1
+++ b/docs/man/borg-key-import.1
@@ -27,7 +27,7 @@ level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .in \\n[rst2man-indent\\n[rst2man-indent-level]]u
 ..
-.TH "BORG-KEY-IMPORT" 1 "2022-06-26" "" "borg backup tool"
+.TH "BORG-KEY-IMPORT" 1 "2022-07-03" "" "borg backup tool"
 .SH NAME
 borg-key-import \- Import the repository key from backup
 .SH SYNOPSIS
diff --git a/docs/man/borg-key.1 b/docs/man/borg-key.1
index e83344501..3c8ea3c6e 100644
--- a/docs/man/borg-key.1
+++ b/docs/man/borg-key.1
@@ -27,7 +27,7 @@ level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .in \\n[rst2man-indent\\n[rst2man-indent-level]]u
 ..
-.TH "BORG-KEY" 1 "2022-06-26" "" "borg backup tool"
+.TH "BORG-KEY" 1 "2022-07-03" "" "borg backup tool"
 .SH NAME
 borg-key \- Manage a keyfile or repokey of a repository
 .SH SYNOPSIS
@@ -36,12 +36,11 @@ borg [common options] key export ...
 borg [common options] key import ...
 borg [common options] key change\-passphrase ...
 borg [common options] key change\-location ...
-borg [common options] key change\-algorithm ...
 .fi
 .sp
 .SH SEE ALSO
 .sp
-\fIborg\-common(1)\fP, \fIborg\-key\-export(1)\fP, \fIborg\-key\-import(1)\fP, \fIborg\-key\-change\-passphrase(1)\fP, \fIborg\-key\-change\-location(1)\fP, \fIborg\-key\-change\-algorithm(1)\fP
+\fIborg\-common(1)\fP, \fIborg\-key\-export(1)\fP, \fIborg\-key\-import(1)\fP, \fIborg\-key\-change\-passphrase(1)\fP, \fIborg\-key\-change\-location(1)\fP
 .SH AUTHOR
 The Borg Collective
 .\" Generated by docutils manpage writer.
diff --git a/docs/man/borg-list.1 b/docs/man/borg-list.1
index 8a40d16b1..f2ad55de7 100644
--- a/docs/man/borg-list.1
+++ b/docs/man/borg-list.1
@@ -27,7 +27,7 @@ level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .in \\n[rst2man-indent\\n[rst2man-indent-level]]u
 ..
-.TH "BORG-LIST" 1 "2022-06-26" "" "borg backup tool"
+.TH "BORG-LIST" 1 "2022-07-03" "" "borg backup tool"
 .SH NAME
 borg-list \- List archive contents
 .SH SYNOPSIS
diff --git a/docs/man/borg-mount.1 b/docs/man/borg-mount.1
index e16b71dd2..8fff78e0a 100644
--- a/docs/man/borg-mount.1
+++ b/docs/man/borg-mount.1
@@ -27,7 +27,7 @@ level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .in \\n[rst2man-indent\\n[rst2man-indent-level]]u
 ..
-.TH "BORG-MOUNT" 1 "2022-06-26" "" "borg backup tool"
+.TH "BORG-MOUNT" 1 "2022-07-03" "" "borg backup tool"
 .SH NAME
 borg-mount \- Mount archive or an entire repository as a FUSE filesystem
 .SH SYNOPSIS
@@ -35,10 +35,13 @@ borg-mount \- Mount archive or an entire repository as a FUSE filesystem
 borg [common options] mount [options] MOUNTPOINT [PATH...]
 .SH DESCRIPTION
 .sp
-This command mounts an archive as a FUSE filesystem. This can be useful for
-browsing an archive or restoring individual files. Unless the \fB\-\-foreground\fP
-option is given the command will run in the background until the filesystem
-is \fBumounted\fP\&.
+This command mounts an archive as a FUSE filesystem. This can be useful
+for browsing an archive or restoring individual files. When restoring,
+take into account that the current FUSE implementation does not support
+special fs flags and ACLs.
+.sp
+Unless the \fB\-\-foreground\fP option is given the command will run in the
+background until the filesystem is \fBumounted\fP\&.
 .sp
 The command \fBborgfs\fP provides a wrapper for \fBborg mount\fP\&. This can also be
 used in fstab entries:
@@ -116,20 +119,14 @@ stay in foreground, do not daemonize
 .B  \-o
 Extra mount options
 .TP
-.B  \-\-numeric\-owner
-deprecated, use \fB\-\-numeric\-ids\fP instead
-.TP
 .B  \-\-numeric\-ids
 use numeric user and group identifiers from archive(s)
 .UNINDENT
 .SS Archive filters
 .INDENT 0.0
 .TP
-.BI \-P \ PREFIX\fR,\fB \ \-\-prefix \ PREFIX
-only consider archive names starting with this prefix.
-.TP
 .BI \-a \ GLOB\fR,\fB \ \-\-glob\-archives \ GLOB
-only consider archive names matching the glob. sh: rules apply, see "borg help patterns". \fB\-\-prefix\fP and \fB\-\-glob\-archives\fP are mutually exclusive.
+only consider archive names matching the glob. sh: rules apply, see "borg help patterns".
 .TP
 .BI \-\-sort\-by \ KEYS
 Comma\-separated list of sorting keys; valid keys are: timestamp, name, id; default is: timestamp
diff --git a/docs/man/borg-patterns.1 b/docs/man/borg-patterns.1
index 3165853ce..a0b998af4 100644
--- a/docs/man/borg-patterns.1
+++ b/docs/man/borg-patterns.1
@@ -27,7 +27,7 @@ level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .in \\n[rst2man-indent\\n[rst2man-indent-level]]u
 ..
-.TH "BORG-PATTERNS" 1 "2022-06-26" "" "borg backup tool"
+.TH "BORG-PATTERNS" 1 "2022-07-03" "" "borg backup tool"
 .SH NAME
 borg-patterns \- Details regarding patterns
 .SH DESCRIPTION
diff --git a/docs/man/borg-placeholders.1 b/docs/man/borg-placeholders.1
index c22cc3042..9d6b638a1 100644
--- a/docs/man/borg-placeholders.1
+++ b/docs/man/borg-placeholders.1
@@ -27,12 +27,12 @@ level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .in \\n[rst2man-indent\\n[rst2man-indent-level]]u
 ..
-.TH "BORG-PLACEHOLDERS" 1 "2022-06-26" "" "borg backup tool"
+.TH "BORG-PLACEHOLDERS" 1 "2022-07-03" "" "borg backup tool"
 .SH NAME
 borg-placeholders \- Details regarding placeholders
 .SH DESCRIPTION
 .sp
-Repository URLs, \fB\-\-name\fP, \fB\-\-prefix\fP, \fB\-\-glob\-archives\fP, \fB\-\-comment\fP
+Repository URLs, \fB\-\-name\fP, \fB\-a\fP / \fB\-\-glob\-archives\fP, \fB\-\-comment\fP
 and \fB\-\-remote\-path\fP values support these placeholders:
 .INDENT 0.0
 .TP
@@ -92,7 +92,7 @@ Examples:
 .ft C
 borg create /path/to/repo::{hostname}\-{user}\-{utcnow} ...
 borg create /path/to/repo::{hostname}\-{now:%Y\-%m\-%d_%H:%M:%S} ...
-borg prune \-\-prefix \(aq{hostname}\-\(aq ...
+borg prune \-a \(aq{hostname}\-*\(aq ...
 .ft P
 .fi
 .UNINDENT
diff --git a/docs/man/borg-prune.1 b/docs/man/borg-prune.1
index f15640b7e..9bfcf63d2 100644
--- a/docs/man/borg-prune.1
+++ b/docs/man/borg-prune.1
@@ -27,7 +27,7 @@ level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .in \\n[rst2man-indent\\n[rst2man-indent-level]]u
 ..
-.TH "BORG-PRUNE" 1 "2022-06-26" "" "borg backup tool"
+.TH "BORG-PRUNE" 1 "2022-07-03" "" "borg backup tool"
 .SH NAME
 borg-prune \- Prune repository archives according to specified rules
 .SH SYNOPSIS
@@ -136,11 +136,8 @@ work slower, but using less space
 .SS Archive filters
 .INDENT 0.0
 .TP
-.BI \-P \ PREFIX\fR,\fB \ \-\-prefix \ PREFIX
-only consider archive names starting with this prefix.
-.TP
 .BI \-a \ GLOB\fR,\fB \ \-\-glob\-archives \ GLOB
-only consider archive names matching the glob. sh: rules apply, see "borg help patterns". \fB\-\-prefix\fP and \fB\-\-glob\-archives\fP are mutually exclusive.
+only consider archive names matching the glob. sh: rules apply, see "borg help patterns".
 .UNINDENT
 .SH EXAMPLES
 .sp
@@ -148,8 +145,8 @@ Be careful, prune is a potentially dangerous command, it will remove backup
 archives.
 .sp
 The default of prune is to apply to \fBall archives in the repository\fP unless
-you restrict its operation to a subset of the archives using \fB\-\-prefix\fP\&.
-When using \fB\-\-prefix\fP, be careful to choose a good prefix \- e.g. do not use a
+you restrict its operation to a subset of the archives using \fB\-a\fP / \fB\-\-glob\-archives\fP\&.
+When using \fB\-a\fP, be careful to choose a good pattern \- e.g. do not use a
 prefix "foo" if you do not also want to match "foobar".
 .sp
 It is strongly recommended to always run \fBprune \-v \-\-list \-\-dry\-run ...\fP
@@ -165,7 +162,7 @@ $ borg prune \-v \-\-list \-\-dry\-run \-\-keep\-daily=7 \-\-keep\-weekly=4
 
 # Same as above but only apply to archive names starting with the hostname
 # of the machine followed by a "\-" character:
-$ borg prune \-v \-\-list \-\-keep\-daily=7 \-\-keep\-weekly=4 \-\-prefix=\(aq{hostname}\-\(aq
+$ borg prune \-v \-\-list \-\-keep\-daily=7 \-\-keep\-weekly=4 \-a \(aq{hostname}\-*\(aq
 # actually free disk space:
 $ borg compact
 
diff --git a/docs/man/borg-rcreate.1 b/docs/man/borg-rcreate.1
index 3f4efc029..bc3ad14e6 100644
--- a/docs/man/borg-rcreate.1
+++ b/docs/man/borg-rcreate.1
@@ -27,7 +27,7 @@ level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .in \\n[rst2man-indent\\n[rst2man-indent-level]]u
 ..
-.TH "BORG-RCREATE" 1 "2022-06-26" "" "borg backup tool"
+.TH "BORG-RCREATE" 1 "2022-07-03" "" "borg backup tool"
 .SH NAME
 borg-rcreate \- Create a new, empty repository
 .SH SYNOPSIS
@@ -251,25 +251,6 @@ case of malicious activity in the repository.
 .sp
 If you do \fBnot\fP want to encrypt the contents of your backups, but still want to detect
 malicious tampering use an \fIauthenticated\fP mode. It\(aqs like \fIrepokey\fP minus encryption.
-.SS Key derivation functions
-.INDENT 0.0
-.IP \(bu 2
-\fB\-\-key\-algorithm argon2\fP is the default and is recommended.
-The key encryption key is derived from your passphrase via argon2\-id.
-Argon2 is considered more modern and secure than pbkdf2.
-.UNINDENT
-.sp
-Our implementation of argon2\-based key algorithm follows the cryptographic best practices:
-.INDENT 0.0
-.IP \(bu 2
-It derives two separate keys from your passphrase: one to encrypt your key and another one
-to sign it. \fB\-\-key\-algorithm pbkdf2\fP uses the same key for both.
-.IP \(bu 2
-It uses encrypt\-then\-mac instead of encrypt\-and\-mac used by \fB\-\-key\-algorithm pbkdf2\fP
-.UNINDENT
-.sp
-Neither is inherently linked to the key derivation function, but since we were going
-to break backwards compatibility anyway we took the opportunity to fix all 3 issues at once.
 .SH OPTIONS
 .sp
 See \fIborg\-common(1)\fP for common options of Borg commands.
@@ -290,9 +271,6 @@ Set storage quota of the new repository (e.g. 5G, 1.5T). Default: no quota.
 .TP
 .B  \-\-make\-parent\-dirs
 create the parent directories of the repository directory, if they are missing.
-.TP
-.B  \-\-key\-algorithm
-the algorithm we use to derive a key encryption key from your passphrase. Default: argon2
 .UNINDENT
 .SH EXAMPLES
 .INDENT 0.0
diff --git a/docs/man/borg-rdelete.1 b/docs/man/borg-rdelete.1
index d6832c436..9b0ab8569 100644
--- a/docs/man/borg-rdelete.1
+++ b/docs/man/borg-rdelete.1
@@ -27,7 +27,7 @@ level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .in \\n[rst2man-indent\\n[rst2man-indent-level]]u
 ..
-.TH "BORG-RDELETE" 1 "2022-06-26" "" "borg backup tool"
+.TH "BORG-RDELETE" 1 "2022-07-03" "" "borg backup tool"
 .SH NAME
 borg-rdelete \- Delete a repository
 .SH SYNOPSIS
diff --git a/docs/man/borg-recreate.1 b/docs/man/borg-recreate.1
index 1a45294f1..c26cd79ab 100644
--- a/docs/man/borg-recreate.1
+++ b/docs/man/borg-recreate.1
@@ -27,7 +27,7 @@ level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .in \\n[rst2man-indent\\n[rst2man-indent-level]]u
 ..
-.TH "BORG-RECREATE" 1 "2022-06-26" "" "borg backup tool"
+.TH "BORG-RECREATE" 1 "2022-07-03" "" "borg backup tool"
 .SH NAME
 borg-recreate \- Re-create archives
 .SH SYNOPSIS
@@ -136,11 +136,8 @@ if tag objects are specified with \fB\-\-exclude\-if\-present\fP, don\(aqt omit
 .SS Archive filters
 .INDENT 0.0
 .TP
-.BI \-P \ PREFIX\fR,\fB \ \-\-prefix \ PREFIX
-only consider archive names starting with this prefix.
-.TP
 .BI \-a \ GLOB\fR,\fB \ \-\-glob\-archives \ GLOB
-only consider archive names matching the glob. sh: rules apply, see "borg help patterns". \fB\-\-prefix\fP and \fB\-\-glob\-archives\fP are mutually exclusive.
+only consider archive names matching the glob. sh: rules apply, see "borg help patterns".
 .TP
 .BI \-\-sort\-by \ KEYS
 Comma\-separated list of sorting keys; valid keys are: timestamp, name, id; default is: timestamp
diff --git a/docs/man/borg-rename.1 b/docs/man/borg-rename.1
index 8e848e5b8..cbf7954a6 100644
--- a/docs/man/borg-rename.1
+++ b/docs/man/borg-rename.1
@@ -27,7 +27,7 @@ level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .in \\n[rst2man-indent\\n[rst2man-indent-level]]u
 ..
-.TH "BORG-RENAME" 1 "2022-06-26" "" "borg backup tool"
+.TH "BORG-RENAME" 1 "2022-07-03" "" "borg backup tool"
 .SH NAME
 borg-rename \- Rename an existing archive
 .SH SYNOPSIS
diff --git a/docs/man/borg-rinfo.1 b/docs/man/borg-rinfo.1
index 5982ad19a..cab6310c0 100644
--- a/docs/man/borg-rinfo.1
+++ b/docs/man/borg-rinfo.1
@@ -27,7 +27,7 @@ level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .in \\n[rst2man-indent\\n[rst2man-indent-level]]u
 ..
-.TH "BORG-RINFO" 1 "2022-06-26" "" "borg backup tool"
+.TH "BORG-RINFO" 1 "2022-07-03" "" "borg backup tool"
 .SH NAME
 borg-rinfo \- Show repository infos
 .SH SYNOPSIS
diff --git a/docs/man/borg-rlist.1 b/docs/man/borg-rlist.1
index 1511e6f6b..b7e4f5116 100644
--- a/docs/man/borg-rlist.1
+++ b/docs/man/borg-rlist.1
@@ -27,7 +27,7 @@ level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .in \\n[rst2man-indent\\n[rst2man-indent-level]]u
 ..
-.TH "BORG-RLIST" 1 "2022-06-26" "" "borg backup tool"
+.TH "BORG-RLIST" 1 "2022-07-03" "" "borg backup tool"
 .SH NAME
 borg-rlist \- List the archives contained in a repository
 .SH SYNOPSIS
@@ -57,11 +57,8 @@ Format output as JSON. The form of \fB\-\-format\fP is ignored, but keys used in
 .SS Archive filters
 .INDENT 0.0
 .TP
-.BI \-P \ PREFIX\fR,\fB \ \-\-prefix \ PREFIX
-only consider archive names starting with this prefix.
-.TP
 .BI \-a \ GLOB\fR,\fB \ \-\-glob\-archives \ GLOB
-only consider archive names matching the glob. sh: rules apply, see "borg help patterns". \fB\-\-prefix\fP and \fB\-\-glob\-archives\fP are mutually exclusive.
+only consider archive names matching the glob. sh: rules apply, see "borg help patterns".
 .TP
 .BI \-\-sort\-by \ KEYS
 Comma\-separated list of sorting keys; valid keys are: timestamp, name, id; default is: timestamp
diff --git a/docs/man/borg-serve.1 b/docs/man/borg-serve.1
index ee6acff53..524b2a194 100644
--- a/docs/man/borg-serve.1
+++ b/docs/man/borg-serve.1
@@ -27,7 +27,7 @@ level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .in \\n[rst2man-indent\\n[rst2man-indent-level]]u
 ..
-.TH "BORG-SERVE" 1 "2022-06-26" "" "borg backup tool"
+.TH "BORG-SERVE" 1 "2022-07-03" "" "borg backup tool"
 .SH NAME
 borg-serve \- Start in server mode. This command is usually not used manually.
 .SH SYNOPSIS
diff --git a/docs/man/borg-transfer.1 b/docs/man/borg-transfer.1
index 348bc8089..3c4e2a280 100644
--- a/docs/man/borg-transfer.1
+++ b/docs/man/borg-transfer.1
@@ -27,17 +27,18 @@ level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .in \\n[rst2man-indent\\n[rst2man-indent-level]]u
 ..
-.TH "BORG-TRANSFER" 1 "2022-06-26" "" "borg backup tool"
+.TH "BORG-TRANSFER" 1 "2022-07-03" "" "borg backup tool"
 .SH NAME
-borg-transfer \- archives transfer from other repository
+borg-transfer \- archives transfer from other repository, optionally upgrade data format
 .SH SYNOPSIS
 .sp
 borg [common options] transfer [options]
 .SH DESCRIPTION
 .sp
 This command transfers archives from one repository to another repository.
+Optionally, it can also upgrade the transferred data.
 .sp
-Suggested use:
+Suggested use for general purpose archive transfer (not repo upgrades):
 .INDENT 0.0
 .INDENT 3.5
 .sp
@@ -61,6 +62,19 @@ The default is to transfer all archives, including checkpoint archives.
 You could use the misc. archive filter options to limit which archives it will
 transfer, e.g. using the \-a option. This is recommended for big
 repositories with multiple data sets to keep the runtime per invocation lower.
+.sp
+For repository upgrades (e.g. from a borg 1.2 repo to a related borg 2.0 repo), usage is
+quite similar to the above:
+.INDENT 0.0
+.INDENT 3.5
+.sp
+.nf
+.ft C
+borg \-\-repo=DST_REPO transfer \-\-other\-repo=SRC_REPO \-\-upgrader=From12To20
+.ft P
+.fi
+.UNINDENT
+.UNINDENT
 .SH OPTIONS
 .sp
 See \fIborg\-common(1)\fP for common options of Borg commands.
@@ -72,15 +86,15 @@ do not change repository, just check
 .TP
 .BI \-\-other\-repo \ SRC_REPOSITORY
 transfer archives from the other repository
+.TP
+.BI \-\-upgrader \ UPGRADER
+use the upgrader to convert transferred data (default: no conversion)
 .UNINDENT
 .SS Archive filters
 .INDENT 0.0
 .TP
-.BI \-P \ PREFIX\fR,\fB \ \-\-prefix \ PREFIX
-only consider archive names starting with this prefix.
-.TP
 .BI \-a \ GLOB\fR,\fB \ \-\-glob\-archives \ GLOB
-only consider archive names matching the glob. sh: rules apply, see "borg help patterns". \fB\-\-prefix\fP and \fB\-\-glob\-archives\fP are mutually exclusive.
+only consider archive names matching the glob. sh: rules apply, see "borg help patterns".
 .TP
 .BI \-\-sort\-by \ KEYS
 Comma\-separated list of sorting keys; valid keys are: timestamp, name, id; default is: timestamp
diff --git a/docs/man/borg-umount.1 b/docs/man/borg-umount.1
index 6694cf15c..73bdcd851 100644
--- a/docs/man/borg-umount.1
+++ b/docs/man/borg-umount.1
@@ -27,7 +27,7 @@ level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .in \\n[rst2man-indent\\n[rst2man-indent-level]]u
 ..
-.TH "BORG-UMOUNT" 1 "2022-06-26" "" "borg backup tool"
+.TH "BORG-UMOUNT" 1 "2022-07-03" "" "borg backup tool"
 .SH NAME
 borg-umount \- un-mount the FUSE filesystem
 .SH SYNOPSIS
diff --git a/docs/man/borg-with-lock.1 b/docs/man/borg-with-lock.1
index dc146b44d..23caa35a7 100644
--- a/docs/man/borg-with-lock.1
+++ b/docs/man/borg-with-lock.1
@@ -27,7 +27,7 @@ level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .in \\n[rst2man-indent\\n[rst2man-indent-level]]u
 ..
-.TH "BORG-WITH-LOCK" 1 "2022-06-26" "" "borg backup tool"
+.TH "BORG-WITH-LOCK" 1 "2022-07-03" "" "borg backup tool"
 .SH NAME
 borg-with-lock \- run a user specified command with the repository lock held
 .SH SYNOPSIS
diff --git a/docs/man/borg.1 b/docs/man/borg.1
index 9cd0d58a7..713cfe135 100644
--- a/docs/man/borg.1
+++ b/docs/man/borg.1
@@ -27,7 +27,7 @@ level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .in \\n[rst2man-indent\\n[rst2man-indent-level]]u
 ..
-.TH "BORG" 1 "2022-06-26" "" "borg backup tool"
+.TH "BORG" 1 "2022-07-03" "" "borg backup tool"
 .SH NAME
 borg \- deduplicating and encrypting backup tool
 .SH SYNOPSIS
diff --git a/docs/man/borgfs.1 b/docs/man/borgfs.1
index 1bad87165..3af78caa3 100644
--- a/docs/man/borgfs.1
+++ b/docs/man/borgfs.1
@@ -27,7 +27,7 @@ level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .in \\n[rst2man-indent\\n[rst2man-indent-level]]u
 ..
-.TH "BORGFS" 1 "2022-06-26" "" "borg backup tool"
+.TH "BORGFS" 1 "2022-07-03" "" "borg backup tool"
 .SH NAME
 borgfs \- Mount archive or an entire repository as a FUSE filesystem
 .SH SYNOPSIS
@@ -35,10 +35,13 @@ borgfs \- Mount archive or an entire repository as a FUSE filesystem
 borgfs [options] MOUNTPOINT [PATH...]
 .SH DESCRIPTION
 .sp
-This command mounts an archive as a FUSE filesystem. This can be useful for
-browsing an archive or restoring individual files. Unless the \fB\-\-foreground\fP
-option is given the command will run in the background until the filesystem
-is \fBumounted\fP\&.
+This command mounts an archive as a FUSE filesystem. This can be useful
+for browsing an archive or restoring individual files. When restoring,
+take into account that the current FUSE implementation does not support
+special fs flags and ACLs.
+.sp
+Unless the \fB\-\-foreground\fP option is given the command will run in the
+background until the filesystem is \fBumounted\fP\&.
 .sp
 The command \fBborgfs\fP provides a wrapper for \fBborg mount\fP\&. This can also be
 used in fstab entries:
@@ -119,20 +122,14 @@ stay in foreground, do not daemonize
 .B  \-o
 Extra mount options
 .TP
-.B  \-\-numeric\-owner
-deprecated, use \fB\-\-numeric\-ids\fP instead
-.TP
 .B  \-\-numeric\-ids
 use numeric user and group identifiers from archive(s)
 .UNINDENT
 .SS Archive filters
 .INDENT 0.0
 .TP
-.BI \-P \ PREFIX\fR,\fB \ \-\-prefix \ PREFIX
-only consider archive names starting with this prefix.
-.TP
 .BI \-a \ GLOB\fR,\fB \ \-\-glob\-archives \ GLOB
-only consider archive names matching the glob. sh: rules apply, see "borg help patterns". \fB\-\-prefix\fP and \fB\-\-glob\-archives\fP are mutually exclusive.
+only consider archive names matching the glob. sh: rules apply, see "borg help patterns".
 .TP
 .BI \-\-sort\-by \ KEYS
 Comma\-separated list of sorting keys; valid keys are: timestamp, name, id; default is: timestamp
diff --git a/docs/usage/check.rst.inc b/docs/usage/check.rst.inc
index e6bb5dcb4..c1d52cb13 100644
--- a/docs/usage/check.rst.inc
+++ b/docs/usage/check.rst.inc
@@ -12,37 +12,35 @@ borg check
 
     .. class:: borg-options-table
 
-    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------+
-    | **optional arguments**                                                                                                                                                                                                                                                       |
-    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------+
-    |                                                                             | ``--repository-only``                 | only perform repository checks                                                                                                                         |
-    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------+
-    |                                                                             | ``--archives-only``                   | only perform archives checks                                                                                                                           |
-    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------+
-    |                                                                             | ``--verify-data``                     | perform cryptographic archive data integrity verification (conflicts with ``--repository-only``)                                                       |
-    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------+
-    |                                                                             | ``--repair``                          | attempt to repair any inconsistencies found                                                                                                            |
-    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------+
-    |                                                                             | ``--save-space``                      | work slower, but using less space                                                                                                                      |
-    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------+
-    |                                                                             | ``--max-duration SECONDS``            | do only a partial repo check for max. SECONDS seconds (Default: unlimited)                                                                             |
-    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------+
-    | .. class:: borg-common-opt-ref                                                                                                                                                                                                                                               |
-    |                                                                                                                                                                                                                                                                              |
-    | :ref:`common_options`                                                                                                                                                                                                                                                        |
-    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------+
-    | **Archive filters** — Archive filters can be applied to repository targets.                                                                                                                                                                                                  |
-    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------+
-    |                                                                             | ``-P PREFIX``, ``--prefix PREFIX``    | only consider archive names starting with this prefix.                                                                                                 |
-    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------+
-    |                                                                             | ``-a GLOB``, ``--glob-archives GLOB`` | only consider archive names matching the glob. sh: rules apply, see "borg help patterns". ``--prefix`` and ``--glob-archives`` are mutually exclusive. |
-    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------+
-    |                                                                             | ``--sort-by KEYS``                    | Comma-separated list of sorting keys; valid keys are: timestamp, name, id; default is: timestamp                                                       |
-    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------+
-    |                                                                             | ``--first N``                         | consider first N archives after other filters were applied                                                                                             |
-    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------+
-    |                                                                             | ``--last N``                          | consider last N archives after other filters were applied                                                                                              |
-    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------+
+    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------+
+    | **optional arguments**                                                                                                                                                                                                 |
+    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------+
+    |                                                                             | ``--repository-only``                 | only perform repository checks                                                                   |
+    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------+
+    |                                                                             | ``--archives-only``                   | only perform archives checks                                                                     |
+    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------+
+    |                                                                             | ``--verify-data``                     | perform cryptographic archive data integrity verification (conflicts with ``--repository-only``) |
+    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------+
+    |                                                                             | ``--repair``                          | attempt to repair any inconsistencies found                                                      |
+    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------+
+    |                                                                             | ``--save-space``                      | work slower, but using less space                                                                |
+    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------+
+    |                                                                             | ``--max-duration SECONDS``            | do only a partial repo check for max. SECONDS seconds (Default: unlimited)                       |
+    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------+
+    | .. class:: borg-common-opt-ref                                                                                                                                                                                         |
+    |                                                                                                                                                                                                                        |
+    | :ref:`common_options`                                                                                                                                                                                                  |
+    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------+
+    | **Archive filters** — Archive filters can be applied to repository targets.                                                                                                                                            |
+    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------+
+    |                                                                             | ``-a GLOB``, ``--glob-archives GLOB`` | only consider archive names matching the glob. sh: rules apply, see "borg help patterns".        |
+    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------+
+    |                                                                             | ``--sort-by KEYS``                    | Comma-separated list of sorting keys; valid keys are: timestamp, name, id; default is: timestamp |
+    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------+
+    |                                                                             | ``--first N``                         | consider first N archives after other filters were applied                                       |
+    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------+
+    |                                                                             | ``--last N``                          | consider last N archives after other filters were applied                                        |
+    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------+
 
     .. raw:: html
 
@@ -69,8 +67,7 @@ borg check
         |
 
     Archive filters
-        -P PREFIX, --prefix PREFIX        only consider archive names starting with this prefix.
-        -a GLOB, --glob-archives GLOB     only consider archive names matching the glob. sh: rules apply, see "borg help patterns". ``--prefix`` and ``--glob-archives`` are mutually exclusive.
+        -a GLOB, --glob-archives GLOB     only consider archive names matching the glob. sh: rules apply, see "borg help patterns".
         --sort-by KEYS                    Comma-separated list of sorting keys; valid keys are: timestamp, name, id; default is: timestamp
         --first N                         consider first N archives after other filters were applied
         --last N                          consider last N archives after other filters were applied
diff --git a/docs/usage/common-options.rst.inc b/docs/usage/common-options.rst.inc
index d091d9b98..55dfe05de 100644
--- a/docs/usage/common-options.rst.inc
+++ b/docs/usage/common-options.rst.inc
@@ -14,9 +14,7 @@
 --show-rc                show/log the return code (rc)
 --umask M                set umask to M (local only, default: 0077)
 --remote-path PATH       use PATH as borg executable on the remote (default: "borg")
---remote-ratelimit RATE    deprecated, use ``--upload-ratelimit`` instead
 --upload-ratelimit RATE    set network upload rate limit in kiByte/s (default: 0=unlimited)
---remote-buffer UPLOAD_BUFFER    deprecated, use ``--upload-buffer`` instead
 --upload-buffer UPLOAD_BUFFER    set network upload buffer size in MiB. (default: 0=no buffer)
 --consider-part-files    treat part files like normal files (e.g. to list/extract them)
 --debug-profile FILE     Write execution profile in Borg format into FILE. For local use a Python-compatible file can be generated by suffixing FILE with ".pyprof".
diff --git a/docs/usage/create.rst.inc b/docs/usage/create.rst.inc
index 9fa36fc86..826b423e5 100644
--- a/docs/usage/create.rst.inc
+++ b/docs/usage/create.rst.inc
@@ -75,20 +75,14 @@ borg create
     +-------------------------------------------------------+---------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------+
     |                                                       | ``-x``, ``--one-file-system``                     | stay in the same file system and do not store mount points of other file systems.  This might behave different from your expectations, see the docs. |
     +-------------------------------------------------------+---------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------+
-    |                                                       | ``--numeric-owner``                               | deprecated, use ``--numeric-ids`` instead                                                                                                            |
-    +-------------------------------------------------------+---------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------+
     |                                                       | ``--numeric-ids``                                 | only store numeric user and group identifiers                                                                                                        |
     +-------------------------------------------------------+---------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------+
-    |                                                       | ``--noatime``                                     | do not store atime into archive                                                                                                                      |
-    +-------------------------------------------------------+---------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------+
     |                                                       | ``--atime``                                       | do store atime into archive                                                                                                                          |
     +-------------------------------------------------------+---------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------+
     |                                                       | ``--noctime``                                     | do not store ctime into archive                                                                                                                      |
     +-------------------------------------------------------+---------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------+
     |                                                       | ``--nobirthtime``                                 | do not store birthtime (creation date) into archive                                                                                                  |
     +-------------------------------------------------------+---------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------+
-    |                                                       | ``--nobsdflags``                                  | deprecated, use ``--noflags`` instead                                                                                                                |
-    +-------------------------------------------------------+---------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------+
     |                                                       | ``--noflags``                                     | do not read and store flags (e.g. NODUMP, IMMUTABLE) into archive                                                                                    |
     +-------------------------------------------------------+---------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------+
     |                                                       | ``--noacls``                                      | do not read and store ACLs into archive                                                                                                              |
@@ -163,13 +157,10 @@ borg create
 
     Filesystem options
         -x, --one-file-system     stay in the same file system and do not store mount points of other file systems.  This might behave different from your expectations, see the docs.
-        --numeric-owner           deprecated, use ``--numeric-ids`` instead
         --numeric-ids             only store numeric user and group identifiers
-        --noatime                 do not store atime into archive
         --atime                   do store atime into archive
         --noctime                 do not store ctime into archive
         --nobirthtime             do not store birthtime (creation date) into archive
-        --nobsdflags              deprecated, use ``--noflags`` instead
         --noflags                 do not read and store flags (e.g. NODUMP, IMMUTABLE) into archive
         --noacls                  do not read and store ACLs into archive
         --noxattrs                do not read and store xattrs into archive
diff --git a/docs/usage/delete.rst.inc b/docs/usage/delete.rst.inc
index 1fd9ba8e9..721a7f3d5 100644
--- a/docs/usage/delete.rst.inc
+++ b/docs/usage/delete.rst.inc
@@ -12,41 +12,39 @@ borg delete
 
     .. class:: borg-options-table
 
-    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------+
-    | **optional arguments**                                                                                                                                                                                                                                                       |
-    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------+
-    |                                                                             | ``-n``, ``--dry-run``                 | do not change repository                                                                                                                               |
-    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------+
-    |                                                                             | ``--list``                            | output verbose list of archives                                                                                                                        |
-    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------+
-    |                                                                             | ``--consider-checkpoints``            | consider checkpoint archives for deletion (default: not considered).                                                                                   |
-    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------+
-    |                                                                             | ``-s``, ``--stats``                   | print statistics for the deleted archive                                                                                                               |
-    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------+
-    |                                                                             | ``--cache-only``                      | delete only the local cache for the given repository                                                                                                   |
-    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------+
-    |                                                                             | ``--force``                           | force deletion of corrupted archives, use ``--force --force`` in case ``--force`` does not work.                                                       |
-    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------+
-    |                                                                             | ``--keep-security-info``              | keep the local security info when deleting a repository                                                                                                |
-    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------+
-    |                                                                             | ``--save-space``                      | work slower, but using less space                                                                                                                      |
-    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------+
-    | .. class:: borg-common-opt-ref                                                                                                                                                                                                                                               |
-    |                                                                                                                                                                                                                                                                              |
-    | :ref:`common_options`                                                                                                                                                                                                                                                        |
-    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------+
-    | **Archive filters** — Archive filters can be applied to repository targets.                                                                                                                                                                                                  |
-    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------+
-    |                                                                             | ``-P PREFIX``, ``--prefix PREFIX``    | only consider archive names starting with this prefix.                                                                                                 |
-    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------+
-    |                                                                             | ``-a GLOB``, ``--glob-archives GLOB`` | only consider archive names matching the glob. sh: rules apply, see "borg help patterns". ``--prefix`` and ``--glob-archives`` are mutually exclusive. |
-    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------+
-    |                                                                             | ``--sort-by KEYS``                    | Comma-separated list of sorting keys; valid keys are: timestamp, name, id; default is: timestamp                                                       |
-    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------+
-    |                                                                             | ``--first N``                         | consider first N archives after other filters were applied                                                                                             |
-    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------+
-    |                                                                             | ``--last N``                          | consider last N archives after other filters were applied                                                                                              |
-    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------+
+    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------+
+    | **optional arguments**                                                                                                                                                                                                 |
+    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------+
+    |                                                                             | ``-n``, ``--dry-run``                 | do not change repository                                                                         |
+    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------+
+    |                                                                             | ``--list``                            | output verbose list of archives                                                                  |
+    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------+
+    |                                                                             | ``--consider-checkpoints``            | consider checkpoint archives for deletion (default: not considered).                             |
+    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------+
+    |                                                                             | ``-s``, ``--stats``                   | print statistics for the deleted archive                                                         |
+    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------+
+    |                                                                             | ``--cache-only``                      | delete only the local cache for the given repository                                             |
+    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------+
+    |                                                                             | ``--force``                           | force deletion of corrupted archives, use ``--force --force`` in case ``--force`` does not work. |
+    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------+
+    |                                                                             | ``--keep-security-info``              | keep the local security info when deleting a repository                                          |
+    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------+
+    |                                                                             | ``--save-space``                      | work slower, but using less space                                                                |
+    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------+
+    | .. class:: borg-common-opt-ref                                                                                                                                                                                         |
+    |                                                                                                                                                                                                                        |
+    | :ref:`common_options`                                                                                                                                                                                                  |
+    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------+
+    | **Archive filters** — Archive filters can be applied to repository targets.                                                                                                                                            |
+    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------+
+    |                                                                             | ``-a GLOB``, ``--glob-archives GLOB`` | only consider archive names matching the glob. sh: rules apply, see "borg help patterns".        |
+    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------+
+    |                                                                             | ``--sort-by KEYS``                    | Comma-separated list of sorting keys; valid keys are: timestamp, name, id; default is: timestamp |
+    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------+
+    |                                                                             | ``--first N``                         | consider first N archives after other filters were applied                                       |
+    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------+
+    |                                                                             | ``--last N``                          | consider last N archives after other filters were applied                                        |
+    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------+
 
     .. raw:: html
 
@@ -75,8 +73,7 @@ borg delete
         |
 
     Archive filters
-        -P PREFIX, --prefix PREFIX        only consider archive names starting with this prefix.
-        -a GLOB, --glob-archives GLOB     only consider archive names matching the glob. sh: rules apply, see "borg help patterns". ``--prefix`` and ``--glob-archives`` are mutually exclusive.
+        -a GLOB, --glob-archives GLOB     only consider archive names matching the glob. sh: rules apply, see "borg help patterns".
         --sort-by KEYS                    Comma-separated list of sorting keys; valid keys are: timestamp, name, id; default is: timestamp
         --first N                         consider first N archives after other filters were applied
         --last N                          consider last N archives after other filters were applied
@@ -97,10 +94,8 @@ deleted - the "Deleted data" deduplicated size there is most interesting as
 that is how much your repository will shrink.
 Please note that the "All archives" stats refer to the state after deletion.
 
-You can delete multiple archives by specifying their common prefix, if they
-have one, using the ``--prefix PREFIX`` option. You can also specify a shell
-pattern to match multiple archives using the ``--glob-archives GLOB`` option
-(for more info on these patterns, see :ref:`borg_patterns`). Note that these
-two options are mutually exclusive.
+You can delete multiple archives by specifying a matching shell pattern,
+using the ``--glob-archives GLOB`` option (for more info on these patterns,
+see :ref:`borg_patterns`).
 
 Always first use ``--dry-run --list`` to see what would be deleted.
\ No newline at end of file
diff --git a/docs/usage/diff.rst.inc b/docs/usage/diff.rst.inc
index 11d97fbfb..b759b96e1 100644
--- a/docs/usage/diff.rst.inc
+++ b/docs/usage/diff.rst.inc
@@ -23,8 +23,6 @@ borg diff
     +-------------------------------------------------------+---------------------------------------+-----------------------------------------------------------------------+
     | **optional arguments**                                                                                                                                                |
     +-------------------------------------------------------+---------------------------------------+-----------------------------------------------------------------------+
-    |                                                       | ``--numeric-owner``                   | deprecated, use ``--numeric-ids`` instead                             |
-    +-------------------------------------------------------+---------------------------------------+-----------------------------------------------------------------------+
     |                                                       | ``--numeric-ids``                     | only consider numeric user and group identifiers                      |
     +-------------------------------------------------------+---------------------------------------+-----------------------------------------------------------------------+
     |                                                       | ``--same-chunker-params``             | Override check of chunker parameters.                                 |
@@ -67,7 +65,6 @@ borg diff
 
 
     optional arguments
-        --numeric-owner    deprecated, use ``--numeric-ids`` instead
         --numeric-ids    only consider numeric user and group identifiers
         --same-chunker-params    Override check of chunker parameters.
         --sort     Sort the output lines by file path.
diff --git a/docs/usage/extract.rst.inc b/docs/usage/extract.rst.inc
index 9bd53bc94..38bd6f78f 100644
--- a/docs/usage/extract.rst.inc
+++ b/docs/usage/extract.rst.inc
@@ -25,12 +25,8 @@ borg extract
     +-------------------------------------------------------+---------------------------------------+-----------------------------------------------------------------------------------------------------------+
     |                                                       | ``-n``, ``--dry-run``                 | do not actually change any files                                                                          |
     +-------------------------------------------------------+---------------------------------------+-----------------------------------------------------------------------------------------------------------+
-    |                                                       | ``--numeric-owner``                   | deprecated, use ``--numeric-ids`` instead                                                                 |
-    +-------------------------------------------------------+---------------------------------------+-----------------------------------------------------------------------------------------------------------+
     |                                                       | ``--numeric-ids``                     | only obey numeric user and group identifiers                                                              |
     +-------------------------------------------------------+---------------------------------------+-----------------------------------------------------------------------------------------------------------+
-    |                                                       | ``--nobsdflags``                      | deprecated, use ``--noflags`` instead                                                                     |
-    +-------------------------------------------------------+---------------------------------------+-----------------------------------------------------------------------------------------------------------+
     |                                                       | ``--noflags``                         | do not extract/set flags (e.g. NODUMP, IMMUTABLE)                                                         |
     +-------------------------------------------------------+---------------------------------------+-----------------------------------------------------------------------------------------------------------+
     |                                                       | ``--noacls``                          | do not extract/set ACLs                                                                                   |
@@ -77,9 +73,7 @@ borg extract
     optional arguments
         --list            output verbose list of items (files, dirs, ...)
         -n, --dry-run     do not actually change any files
-        --numeric-owner    deprecated, use ``--numeric-ids`` instead
         --numeric-ids     only obey numeric user and group identifiers
-        --nobsdflags      deprecated, use ``--noflags`` instead
         --noflags         do not extract/set flags (e.g. NODUMP, IMMUTABLE)
         --noacls          do not extract/set ACLs
         --noxattrs        do not extract/set xattrs
diff --git a/docs/usage/help.rst.inc b/docs/usage/help.rst.inc
index a4c4c975f..6b9e25416 100644
--- a/docs/usage/help.rst.inc
+++ b/docs/usage/help.rst.inc
@@ -246,7 +246,7 @@ borg help placeholders
 ~~~~~~~~~~~~~~~~~~~~~~
 
 
-Repository URLs, ``--name``, ``--prefix``, ``--glob-archives``, ``--comment``
+Repository URLs, ``--name``, ``-a`` / ``--glob-archives``, ``--comment``
 and ``--remote-path`` values support these placeholders:
 
 {hostname}
@@ -292,7 +292,7 @@ Examples::
 
     borg create /path/to/repo::{hostname}-{user}-{utcnow} ...
     borg create /path/to/repo::{hostname}-{now:%Y-%m-%d_%H:%M:%S} ...
-    borg prune --prefix '{hostname}-' ...
+    borg prune -a '{hostname}-*' ...
 
 .. note::
     systemd uses a difficult, non-standard syntax for command lines in unit files (refer to
diff --git a/docs/usage/info.rst.inc b/docs/usage/info.rst.inc
index 915ffca6f..baf3acbfe 100644
--- a/docs/usage/info.rst.inc
+++ b/docs/usage/info.rst.inc
@@ -12,27 +12,25 @@ borg info
 
     .. class:: borg-options-table
 
-    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------+
-    | **optional arguments**                                                                                                                                                                                                                                                       |
-    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------+
-    |                                                                             | ``--json``                            | format output as JSON                                                                                                                                  |
-    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------+
-    | .. class:: borg-common-opt-ref                                                                                                                                                                                                                                               |
-    |                                                                                                                                                                                                                                                                              |
-    | :ref:`common_options`                                                                                                                                                                                                                                                        |
-    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------+
-    | **Archive filters** — Archive filters can be applied to repository targets.                                                                                                                                                                                                  |
-    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------+
-    |                                                                             | ``-P PREFIX``, ``--prefix PREFIX``    | only consider archive names starting with this prefix.                                                                                                 |
-    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------+
-    |                                                                             | ``-a GLOB``, ``--glob-archives GLOB`` | only consider archive names matching the glob. sh: rules apply, see "borg help patterns". ``--prefix`` and ``--glob-archives`` are mutually exclusive. |
-    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------+
-    |                                                                             | ``--sort-by KEYS``                    | Comma-separated list of sorting keys; valid keys are: timestamp, name, id; default is: timestamp                                                       |
-    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------+
-    |                                                                             | ``--first N``                         | consider first N archives after other filters were applied                                                                                             |
-    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------+
-    |                                                                             | ``--last N``                          | consider last N archives after other filters were applied                                                                                              |
-    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------+
+    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------+
+    | **optional arguments**                                                                                                                                                                                                 |
+    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------+
+    |                                                                             | ``--json``                            | format output as JSON                                                                            |
+    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------+
+    | .. class:: borg-common-opt-ref                                                                                                                                                                                         |
+    |                                                                                                                                                                                                                        |
+    | :ref:`common_options`                                                                                                                                                                                                  |
+    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------+
+    | **Archive filters** — Archive filters can be applied to repository targets.                                                                                                                                            |
+    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------+
+    |                                                                             | ``-a GLOB``, ``--glob-archives GLOB`` | only consider archive names matching the glob. sh: rules apply, see "borg help patterns".        |
+    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------+
+    |                                                                             | ``--sort-by KEYS``                    | Comma-separated list of sorting keys; valid keys are: timestamp, name, id; default is: timestamp |
+    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------+
+    |                                                                             | ``--first N``                         | consider first N archives after other filters were applied                                       |
+    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------+
+    |                                                                             | ``--last N``                          | consider last N archives after other filters were applied                                        |
+    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------+
 
     .. raw:: html
 
@@ -54,8 +52,7 @@ borg info
         |
 
     Archive filters
-        -P PREFIX, --prefix PREFIX        only consider archive names starting with this prefix.
-        -a GLOB, --glob-archives GLOB     only consider archive names matching the glob. sh: rules apply, see "borg help patterns". ``--prefix`` and ``--glob-archives`` are mutually exclusive.
+        -a GLOB, --glob-archives GLOB     only consider archive names matching the glob. sh: rules apply, see "borg help patterns".
         --sort-by KEYS                    Comma-separated list of sorting keys; valid keys are: timestamp, name, id; default is: timestamp
         --first N                         consider first N archives after other filters were applied
         --last N                          consider last N archives after other filters were applied
diff --git a/docs/usage/mount.rst.inc b/docs/usage/mount.rst.inc
index 0e3103819..deb1a3cda 100644
--- a/docs/usage/mount.rst.inc
+++ b/docs/usage/mount.rst.inc
@@ -12,53 +12,49 @@ borg mount
 
     .. class:: borg-options-table
 
-    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------+
-    | **positional arguments**                                                                                                                                                                                                                                                     |
-    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------+
-    |                                                                             | ``MOUNTPOINT``                        | where to mount filesystem                                                                                                                              |
-    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------+
-    |                                                                             | ``PATH``                              | paths to extract; patterns are supported                                                                                                               |
-    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------+
-    | **optional arguments**                                                                                                                                                                                                                                                       |
-    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------+
-    |                                                                             | ``--consider-checkpoints``            | Show checkpoint archives in the repository contents list (default: hidden).                                                                            |
-    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------+
-    |                                                                             | ``-f``, ``--foreground``              | stay in foreground, do not daemonize                                                                                                                   |
-    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------+
-    |                                                                             | ``-o``                                | Extra mount options                                                                                                                                    |
-    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------+
-    |                                                                             | ``--numeric-owner``                   | deprecated, use ``--numeric-ids`` instead                                                                                                              |
-    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------+
-    |                                                                             | ``--numeric-ids``                     | use numeric user and group identifiers from archive(s)                                                                                                 |
-    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------+
-    | .. class:: borg-common-opt-ref                                                                                                                                                                                                                                               |
-    |                                                                                                                                                                                                                                                                              |
-    | :ref:`common_options`                                                                                                                                                                                                                                                        |
-    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------+
-    | **Archive filters** — Archive filters can be applied to repository targets.                                                                                                                                                                                                  |
-    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------+
-    |                                                                             | ``-P PREFIX``, ``--prefix PREFIX``    | only consider archive names starting with this prefix.                                                                                                 |
-    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------+
-    |                                                                             | ``-a GLOB``, ``--glob-archives GLOB`` | only consider archive names matching the glob. sh: rules apply, see "borg help patterns". ``--prefix`` and ``--glob-archives`` are mutually exclusive. |
-    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------+
-    |                                                                             | ``--sort-by KEYS``                    | Comma-separated list of sorting keys; valid keys are: timestamp, name, id; default is: timestamp                                                       |
-    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------+
-    |                                                                             | ``--first N``                         | consider first N archives after other filters were applied                                                                                             |
-    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------+
-    |                                                                             | ``--last N``                          | consider last N archives after other filters were applied                                                                                              |
-    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------+
-    | **Exclusion options**                                                                                                                                                                                                                                                        |
-    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------+
-    |                                                                             | ``-e PATTERN``, ``--exclude PATTERN`` | exclude paths matching PATTERN                                                                                                                         |
-    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------+
-    |                                                                             | ``--exclude-from EXCLUDEFILE``        | read exclude patterns from EXCLUDEFILE, one per line                                                                                                   |
-    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------+
-    |                                                                             | ``--pattern PATTERN``                 | include/exclude paths matching PATTERN                                                                                                                 |
-    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------+
-    |                                                                             | ``--patterns-from PATTERNFILE``       | read include/exclude patterns from PATTERNFILE, one per line                                                                                           |
-    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------+
-    |                                                                             | ``--strip-components NUMBER``         | Remove the specified number of leading path elements. Paths with fewer elements will be silently skipped.                                              |
-    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------+
+    +-----------------------------------------------------------------------------+---------------------------------------+-----------------------------------------------------------------------------------------------------------+
+    | **positional arguments**                                                                                                                                                                                                        |
+    +-----------------------------------------------------------------------------+---------------------------------------+-----------------------------------------------------------------------------------------------------------+
+    |                                                                             | ``MOUNTPOINT``                        | where to mount filesystem                                                                                 |
+    +-----------------------------------------------------------------------------+---------------------------------------+-----------------------------------------------------------------------------------------------------------+
+    |                                                                             | ``PATH``                              | paths to extract; patterns are supported                                                                  |
+    +-----------------------------------------------------------------------------+---------------------------------------+-----------------------------------------------------------------------------------------------------------+
+    | **optional arguments**                                                                                                                                                                                                          |
+    +-----------------------------------------------------------------------------+---------------------------------------+-----------------------------------------------------------------------------------------------------------+
+    |                                                                             | ``--consider-checkpoints``            | Show checkpoint archives in the repository contents list (default: hidden).                               |
+    +-----------------------------------------------------------------------------+---------------------------------------+-----------------------------------------------------------------------------------------------------------+
+    |                                                                             | ``-f``, ``--foreground``              | stay in foreground, do not daemonize                                                                      |
+    +-----------------------------------------------------------------------------+---------------------------------------+-----------------------------------------------------------------------------------------------------------+
+    |                                                                             | ``-o``                                | Extra mount options                                                                                       |
+    +-----------------------------------------------------------------------------+---------------------------------------+-----------------------------------------------------------------------------------------------------------+
+    |                                                                             | ``--numeric-ids``                     | use numeric user and group identifiers from archive(s)                                                    |
+    +-----------------------------------------------------------------------------+---------------------------------------+-----------------------------------------------------------------------------------------------------------+
+    | .. class:: borg-common-opt-ref                                                                                                                                                                                                  |
+    |                                                                                                                                                                                                                                 |
+    | :ref:`common_options`                                                                                                                                                                                                           |
+    +-----------------------------------------------------------------------------+---------------------------------------+-----------------------------------------------------------------------------------------------------------+
+    | **Archive filters** — Archive filters can be applied to repository targets.                                                                                                                                                     |
+    +-----------------------------------------------------------------------------+---------------------------------------+-----------------------------------------------------------------------------------------------------------+
+    |                                                                             | ``-a GLOB``, ``--glob-archives GLOB`` | only consider archive names matching the glob. sh: rules apply, see "borg help patterns".                 |
+    +-----------------------------------------------------------------------------+---------------------------------------+-----------------------------------------------------------------------------------------------------------+
+    |                                                                             | ``--sort-by KEYS``                    | Comma-separated list of sorting keys; valid keys are: timestamp, name, id; default is: timestamp          |
+    +-----------------------------------------------------------------------------+---------------------------------------+-----------------------------------------------------------------------------------------------------------+
+    |                                                                             | ``--first N``                         | consider first N archives after other filters were applied                                                |
+    +-----------------------------------------------------------------------------+---------------------------------------+-----------------------------------------------------------------------------------------------------------+
+    |                                                                             | ``--last N``                          | consider last N archives after other filters were applied                                                 |
+    +-----------------------------------------------------------------------------+---------------------------------------+-----------------------------------------------------------------------------------------------------------+
+    | **Exclusion options**                                                                                                                                                                                                           |
+    +-----------------------------------------------------------------------------+---------------------------------------+-----------------------------------------------------------------------------------------------------------+
+    |                                                                             | ``-e PATTERN``, ``--exclude PATTERN`` | exclude paths matching PATTERN                                                                            |
+    +-----------------------------------------------------------------------------+---------------------------------------+-----------------------------------------------------------------------------------------------------------+
+    |                                                                             | ``--exclude-from EXCLUDEFILE``        | read exclude patterns from EXCLUDEFILE, one per line                                                      |
+    +-----------------------------------------------------------------------------+---------------------------------------+-----------------------------------------------------------------------------------------------------------+
+    |                                                                             | ``--pattern PATTERN``                 | include/exclude paths matching PATTERN                                                                    |
+    +-----------------------------------------------------------------------------+---------------------------------------+-----------------------------------------------------------------------------------------------------------+
+    |                                                                             | ``--patterns-from PATTERNFILE``       | read include/exclude patterns from PATTERNFILE, one per line                                              |
+    +-----------------------------------------------------------------------------+---------------------------------------+-----------------------------------------------------------------------------------------------------------+
+    |                                                                             | ``--strip-components NUMBER``         | Remove the specified number of leading path elements. Paths with fewer elements will be silently skipped. |
+    +-----------------------------------------------------------------------------+---------------------------------------+-----------------------------------------------------------------------------------------------------------+
 
     .. raw:: html
 
@@ -80,7 +76,6 @@ borg mount
         --consider-checkpoints    Show checkpoint archives in the repository contents list (default: hidden).
         -f, --foreground    stay in foreground, do not daemonize
         -o     Extra mount options
-        --numeric-owner    deprecated, use ``--numeric-ids`` instead
         --numeric-ids    use numeric user and group identifiers from archive(s)
 
 
@@ -88,8 +83,7 @@ borg mount
         |
 
     Archive filters
-        -P PREFIX, --prefix PREFIX        only consider archive names starting with this prefix.
-        -a GLOB, --glob-archives GLOB     only consider archive names matching the glob. sh: rules apply, see "borg help patterns". ``--prefix`` and ``--glob-archives`` are mutually exclusive.
+        -a GLOB, --glob-archives GLOB     only consider archive names matching the glob. sh: rules apply, see "borg help patterns".
         --sort-by KEYS                    Comma-separated list of sorting keys; valid keys are: timestamp, name, id; default is: timestamp
         --first N                         consider first N archives after other filters were applied
         --last N                          consider last N archives after other filters were applied
@@ -106,10 +100,13 @@ borg mount
 Description
 ~~~~~~~~~~~
 
-This command mounts an archive as a FUSE filesystem. This can be useful for
-browsing an archive or restoring individual files. Unless the ``--foreground``
-option is given the command will run in the background until the filesystem
-is ``umounted``.
+This command mounts an archive as a FUSE filesystem. This can be useful
+for browsing an archive or restoring individual files. When restoring,
+take into account that the current FUSE implementation does not support
+special fs flags and ACLs.
+
+Unless the ``--foreground`` option is given the command will run in the
+background until the filesystem is ``umounted``.
 
 The command ``borgfs`` provides a wrapper for ``borg mount``. This can also be
 used in fstab entries:
diff --git a/docs/usage/prune.rst.inc b/docs/usage/prune.rst.inc
index 1189b68b5..74d8f7e0b 100644
--- a/docs/usage/prune.rst.inc
+++ b/docs/usage/prune.rst.inc
@@ -12,45 +12,43 @@ borg prune
 
     .. class:: borg-options-table
 
-    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------+
-    | **optional arguments**                                                                                                                                                                                                                                                       |
-    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------+
-    |                                                                             | ``-n``, ``--dry-run``                 | do not change repository                                                                                                                               |
-    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------+
-    |                                                                             | ``--force``                           | force pruning of corrupted archives, use ``--force --force`` in case ``--force`` does not work.                                                        |
-    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------+
-    |                                                                             | ``-s``, ``--stats``                   | print statistics for the deleted archive                                                                                                               |
-    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------+
-    |                                                                             | ``--list``                            | output verbose list of archives it keeps/prunes                                                                                                        |
-    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------+
-    |                                                                             | ``--keep-within INTERVAL``            | keep all archives within this time interval                                                                                                            |
-    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------+
-    |                                                                             | ``--keep-last``, ``--keep-secondly``  | number of secondly archives to keep                                                                                                                    |
-    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------+
-    |                                                                             | ``--keep-minutely``                   | number of minutely archives to keep                                                                                                                    |
-    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------+
-    |                                                                             | ``-H``, ``--keep-hourly``             | number of hourly archives to keep                                                                                                                      |
-    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------+
-    |                                                                             | ``-d``, ``--keep-daily``              | number of daily archives to keep                                                                                                                       |
-    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------+
-    |                                                                             | ``-w``, ``--keep-weekly``             | number of weekly archives to keep                                                                                                                      |
-    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------+
-    |                                                                             | ``-m``, ``--keep-monthly``            | number of monthly archives to keep                                                                                                                     |
-    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------+
-    |                                                                             | ``-y``, ``--keep-yearly``             | number of yearly archives to keep                                                                                                                      |
-    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------+
-    |                                                                             | ``--save-space``                      | work slower, but using less space                                                                                                                      |
-    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------+
-    | .. class:: borg-common-opt-ref                                                                                                                                                                                                                                               |
-    |                                                                                                                                                                                                                                                                              |
-    | :ref:`common_options`                                                                                                                                                                                                                                                        |
-    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------+
-    | **Archive filters** — Archive filters can be applied to repository targets.                                                                                                                                                                                                  |
-    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------+
-    |                                                                             | ``-P PREFIX``, ``--prefix PREFIX``    | only consider archive names starting with this prefix.                                                                                                 |
-    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------+
-    |                                                                             | ``-a GLOB``, ``--glob-archives GLOB`` | only consider archive names matching the glob. sh: rules apply, see "borg help patterns". ``--prefix`` and ``--glob-archives`` are mutually exclusive. |
-    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------+
+    +-----------------------------------------------------------------------------+---------------------------------------+-------------------------------------------------------------------------------------------------+
+    | **optional arguments**                                                                                                                                                                                                |
+    +-----------------------------------------------------------------------------+---------------------------------------+-------------------------------------------------------------------------------------------------+
+    |                                                                             | ``-n``, ``--dry-run``                 | do not change repository                                                                        |
+    +-----------------------------------------------------------------------------+---------------------------------------+-------------------------------------------------------------------------------------------------+
+    |                                                                             | ``--force``                           | force pruning of corrupted archives, use ``--force --force`` in case ``--force`` does not work. |
+    +-----------------------------------------------------------------------------+---------------------------------------+-------------------------------------------------------------------------------------------------+
+    |                                                                             | ``-s``, ``--stats``                   | print statistics for the deleted archive                                                        |
+    +-----------------------------------------------------------------------------+---------------------------------------+-------------------------------------------------------------------------------------------------+
+    |                                                                             | ``--list``                            | output verbose list of archives it keeps/prunes                                                 |
+    +-----------------------------------------------------------------------------+---------------------------------------+-------------------------------------------------------------------------------------------------+
+    |                                                                             | ``--keep-within INTERVAL``            | keep all archives within this time interval                                                     |
+    +-----------------------------------------------------------------------------+---------------------------------------+-------------------------------------------------------------------------------------------------+
+    |                                                                             | ``--keep-last``, ``--keep-secondly``  | number of secondly archives to keep                                                             |
+    +-----------------------------------------------------------------------------+---------------------------------------+-------------------------------------------------------------------------------------------------+
+    |                                                                             | ``--keep-minutely``                   | number of minutely archives to keep                                                             |
+    +-----------------------------------------------------------------------------+---------------------------------------+-------------------------------------------------------------------------------------------------+
+    |                                                                             | ``-H``, ``--keep-hourly``             | number of hourly archives to keep                                                               |
+    +-----------------------------------------------------------------------------+---------------------------------------+-------------------------------------------------------------------------------------------------+
+    |                                                                             | ``-d``, ``--keep-daily``              | number of daily archives to keep                                                                |
+    +-----------------------------------------------------------------------------+---------------------------------------+-------------------------------------------------------------------------------------------------+
+    |                                                                             | ``-w``, ``--keep-weekly``             | number of weekly archives to keep                                                               |
+    +-----------------------------------------------------------------------------+---------------------------------------+-------------------------------------------------------------------------------------------------+
+    |                                                                             | ``-m``, ``--keep-monthly``            | number of monthly archives to keep                                                              |
+    +-----------------------------------------------------------------------------+---------------------------------------+-------------------------------------------------------------------------------------------------+
+    |                                                                             | ``-y``, ``--keep-yearly``             | number of yearly archives to keep                                                               |
+    +-----------------------------------------------------------------------------+---------------------------------------+-------------------------------------------------------------------------------------------------+
+    |                                                                             | ``--save-space``                      | work slower, but using less space                                                               |
+    +-----------------------------------------------------------------------------+---------------------------------------+-------------------------------------------------------------------------------------------------+
+    | .. class:: borg-common-opt-ref                                                                                                                                                                                        |
+    |                                                                                                                                                                                                                       |
+    | :ref:`common_options`                                                                                                                                                                                                 |
+    +-----------------------------------------------------------------------------+---------------------------------------+-------------------------------------------------------------------------------------------------+
+    | **Archive filters** — Archive filters can be applied to repository targets.                                                                                                                                           |
+    +-----------------------------------------------------------------------------+---------------------------------------+-------------------------------------------------------------------------------------------------+
+    |                                                                             | ``-a GLOB``, ``--glob-archives GLOB`` | only consider archive names matching the glob. sh: rules apply, see "borg help patterns".       |
+    +-----------------------------------------------------------------------------+---------------------------------------+-------------------------------------------------------------------------------------------------+
 
     .. raw:: html
 
@@ -84,8 +82,7 @@ borg prune
         |
 
     Archive filters
-        -P PREFIX, --prefix PREFIX        only consider archive names starting with this prefix.
-        -a GLOB, --glob-archives GLOB     only consider archive names matching the glob. sh: rules apply, see "borg help patterns". ``--prefix`` and ``--glob-archives`` are mutually exclusive.
+        -a GLOB, --glob-archives GLOB     only consider archive names matching the glob. sh: rules apply, see "borg help patterns".
 
 
 Description
diff --git a/docs/usage/rcreate.rst.inc b/docs/usage/rcreate.rst.inc
index 3a4c99b2b..6f6842417 100644
--- a/docs/usage/rcreate.rst.inc
+++ b/docs/usage/rcreate.rst.inc
@@ -25,8 +25,6 @@ borg rcreate
     +-------------------------------------------------------+------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
     |                                                       | ``--make-parent-dirs``             | create the parent directories of the repository directory, if they are missing.                                                                                                                                                        |
     +-------------------------------------------------------+------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-    |                                                       | ``--key-algorithm``                | the algorithm we use to derive a key encryption key from your passphrase. Default: argon2                                                                                                                                              |
-    +-------------------------------------------------------+------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
     | .. class:: borg-common-opt-ref                                                                                                                                                                                                                                                                                                      |
     |                                                                                                                                                                                                                                                                                                                                     |
     | :ref:`common_options`                                                                                                                                                                                                                                                                                                               |
@@ -50,7 +48,6 @@ borg rcreate
         --append-only                  create an append-only mode repository. Note that this only affects the low level structure of the repository, and running `delete` or `prune` will still be allowed. See :ref:`append_only_mode` in Additional Notes for more details.
         --storage-quota QUOTA          Set storage quota of the new repository (e.g. 5G, 1.5T). Default: no quota.
         --make-parent-dirs             create the parent directories of the repository directory, if they are missing.
-        --key-algorithm                the algorithm we use to derive a key encryption key from your passphrase. Default: argon2
 
 
     :ref:`common_options`
@@ -161,20 +158,3 @@ case of malicious activity in the repository.
 
 If you do **not** want to encrypt the contents of your backups, but still want to detect
 malicious tampering use an `authenticated` mode. It's like `repokey` minus encryption.
-
-Key derivation functions
-++++++++++++++++++++++++
-
-- ``--key-algorithm argon2`` is the default and is recommended.
-  The key encryption key is derived from your passphrase via argon2-id.
-  Argon2 is considered more modern and secure than pbkdf2.
-
-Our implementation of argon2-based key algorithm follows the cryptographic best practices:
-
-- It derives two separate keys from your passphrase: one to encrypt your key and another one
-  to sign it. ``--key-algorithm pbkdf2`` uses the same key for both.
-
-- It uses encrypt-then-mac instead of encrypt-and-mac used by ``--key-algorithm pbkdf2``
-
-Neither is inherently linked to the key derivation function, but since we were going
-to break backwards compatibility anyway we took the opportunity to fix all 3 issues at once.
\ No newline at end of file
diff --git a/docs/usage/recreate.rst.inc b/docs/usage/recreate.rst.inc
index 40dd7b1fe..0c6550654 100644
--- a/docs/usage/recreate.rst.inc
+++ b/docs/usage/recreate.rst.inc
@@ -49,9 +49,7 @@ borg recreate
     +-----------------------------------------------------------------------------+---------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
     | **Archive filters** — Archive filters can be applied to repository targets.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
     +-----------------------------------------------------------------------------+---------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-    |                                                                             | ``-P PREFIX``, ``--prefix PREFIX``                | only consider archive names starting with this prefix.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
-    +-----------------------------------------------------------------------------+---------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-    |                                                                             | ``-a GLOB``, ``--glob-archives GLOB``             | only consider archive names matching the glob. sh: rules apply, see "borg help patterns". ``--prefix`` and ``--glob-archives`` are mutually exclusive.                                                                                                                                                                                                                                                                                                                                                                                                      |
+    |                                                                             | ``-a GLOB``, ``--glob-archives GLOB``             | only consider archive names matching the glob. sh: rules apply, see "borg help patterns".                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
     +-----------------------------------------------------------------------------+---------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
     |                                                                             | ``--sort-by KEYS``                                | Comma-separated list of sorting keys; valid keys are: timestamp, name, id; default is: timestamp                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
     +-----------------------------------------------------------------------------+---------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
@@ -109,8 +107,7 @@ borg recreate
 
 
     Archive filters
-        -P PREFIX, --prefix PREFIX                    only consider archive names starting with this prefix.
-        -a GLOB, --glob-archives GLOB                 only consider archive names matching the glob. sh: rules apply, see "borg help patterns". ``--prefix`` and ``--glob-archives`` are mutually exclusive.
+        -a GLOB, --glob-archives GLOB                 only consider archive names matching the glob. sh: rules apply, see "borg help patterns".
         --sort-by KEYS                                Comma-separated list of sorting keys; valid keys are: timestamp, name, id; default is: timestamp
         --first N                                     consider first N archives after other filters were applied
         --last N                                      consider last N archives after other filters were applied
diff --git a/docs/usage/rlist.rst.inc b/docs/usage/rlist.rst.inc
index 0fec78a3a..e5d3140fc 100644
--- a/docs/usage/rlist.rst.inc
+++ b/docs/usage/rlist.rst.inc
@@ -29,9 +29,7 @@ borg rlist
     +-----------------------------------------------------------------------------+---------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
     | **Archive filters** — Archive filters can be applied to repository targets.                                                                                                                                                                                                                                                                        |
     +-----------------------------------------------------------------------------+---------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-    |                                                                             | ``-P PREFIX``, ``--prefix PREFIX``    | only consider archive names starting with this prefix.                                                                                                                                                                       |
-    +-----------------------------------------------------------------------------+---------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-    |                                                                             | ``-a GLOB``, ``--glob-archives GLOB`` | only consider archive names matching the glob. sh: rules apply, see "borg help patterns". ``--prefix`` and ``--glob-archives`` are mutually exclusive.                                                                       |
+    |                                                                             | ``-a GLOB``, ``--glob-archives GLOB`` | only consider archive names matching the glob. sh: rules apply, see "borg help patterns".                                                                                                                                    |
     +-----------------------------------------------------------------------------+---------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
     |                                                                             | ``--sort-by KEYS``                    | Comma-separated list of sorting keys; valid keys are: timestamp, name, id; default is: timestamp                                                                                                                             |
     +-----------------------------------------------------------------------------+---------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
@@ -63,8 +61,7 @@ borg rlist
         |
 
     Archive filters
-        -P PREFIX, --prefix PREFIX        only consider archive names starting with this prefix.
-        -a GLOB, --glob-archives GLOB     only consider archive names matching the glob. sh: rules apply, see "borg help patterns". ``--prefix`` and ``--glob-archives`` are mutually exclusive.
+        -a GLOB, --glob-archives GLOB     only consider archive names matching the glob. sh: rules apply, see "borg help patterns".
         --sort-by KEYS                    Comma-separated list of sorting keys; valid keys are: timestamp, name, id; default is: timestamp
         --first N                         consider first N archives after other filters were applied
         --last N                          consider last N archives after other filters were applied
diff --git a/docs/usage/transfer.rst.inc b/docs/usage/transfer.rst.inc
index 838a7074e..824c125ef 100644
--- a/docs/usage/transfer.rst.inc
+++ b/docs/usage/transfer.rst.inc
@@ -12,29 +12,29 @@ borg transfer
 
     .. class:: borg-options-table
 
-    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------+
-    | **optional arguments**                                                                                                                                                                                                                                                       |
-    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------+
-    |                                                                             | ``-n``, ``--dry-run``                 | do not change repository, just check                                                                                                                   |
-    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------+
-    |                                                                             | ``--other-repo SRC_REPOSITORY``       | transfer archives from the other repository                                                                                                            |
-    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------+
-    | .. class:: borg-common-opt-ref                                                                                                                                                                                                                                               |
-    |                                                                                                                                                                                                                                                                              |
-    | :ref:`common_options`                                                                                                                                                                                                                                                        |
-    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------+
-    | **Archive filters** — Archive filters can be applied to repository targets.                                                                                                                                                                                                  |
-    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------+
-    |                                                                             | ``-P PREFIX``, ``--prefix PREFIX``    | only consider archive names starting with this prefix.                                                                                                 |
-    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------+
-    |                                                                             | ``-a GLOB``, ``--glob-archives GLOB`` | only consider archive names matching the glob. sh: rules apply, see "borg help patterns". ``--prefix`` and ``--glob-archives`` are mutually exclusive. |
-    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------+
-    |                                                                             | ``--sort-by KEYS``                    | Comma-separated list of sorting keys; valid keys are: timestamp, name, id; default is: timestamp                                                       |
-    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------+
-    |                                                                             | ``--first N``                         | consider first N archives after other filters were applied                                                                                             |
-    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------+
-    |                                                                             | ``--last N``                          | consider last N archives after other filters were applied                                                                                              |
-    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------+
+    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------+
+    | **optional arguments**                                                                                                                                                                                                 |
+    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------+
+    |                                                                             | ``-n``, ``--dry-run``                 | do not change repository, just check                                                             |
+    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------+
+    |                                                                             | ``--other-repo SRC_REPOSITORY``       | transfer archives from the other repository                                                      |
+    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------+
+    |                                                                             | ``--upgrader UPGRADER``               | use the upgrader to convert transferred data (default: no conversion)                            |
+    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------+
+    | .. class:: borg-common-opt-ref                                                                                                                                                                                         |
+    |                                                                                                                                                                                                                        |
+    | :ref:`common_options`                                                                                                                                                                                                  |
+    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------+
+    | **Archive filters** — Archive filters can be applied to repository targets.                                                                                                                                            |
+    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------+
+    |                                                                             | ``-a GLOB``, ``--glob-archives GLOB`` | only consider archive names matching the glob. sh: rules apply, see "borg help patterns".        |
+    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------+
+    |                                                                             | ``--sort-by KEYS``                    | Comma-separated list of sorting keys; valid keys are: timestamp, name, id; default is: timestamp |
+    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------+
+    |                                                                             | ``--first N``                         | consider first N archives after other filters were applied                                       |
+    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------+
+    |                                                                             | ``--last N``                          | consider last N archives after other filters were applied                                        |
+    +-----------------------------------------------------------------------------+---------------------------------------+--------------------------------------------------------------------------------------------------+
 
     .. raw:: html
 
@@ -51,14 +51,14 @@ borg transfer
     optional arguments
         -n, --dry-run     do not change repository, just check
         --other-repo SRC_REPOSITORY    transfer archives from the other repository
+        --upgrader UPGRADER    use the upgrader to convert transferred data (default: no conversion)
 
 
     :ref:`common_options`
         |
 
     Archive filters
-        -P PREFIX, --prefix PREFIX        only consider archive names starting with this prefix.
-        -a GLOB, --glob-archives GLOB     only consider archive names matching the glob. sh: rules apply, see "borg help patterns". ``--prefix`` and ``--glob-archives`` are mutually exclusive.
+        -a GLOB, --glob-archives GLOB     only consider archive names matching the glob. sh: rules apply, see "borg help patterns".
         --sort-by KEYS                    Comma-separated list of sorting keys; valid keys are: timestamp, name, id; default is: timestamp
         --first N                         consider first N archives after other filters were applied
         --last N                          consider last N archives after other filters were applied
@@ -68,8 +68,9 @@ Description
 ~~~~~~~~~~~
 
 This command transfers archives from one repository to another repository.
+Optionally, it can also upgrade the transferred data.
 
-Suggested use::
+Suggested use for general purpose archive transfer (not repo upgrades)::
 
     # initialize DST_REPO reusing key material from SRC_REPO, so that
     # chunking and chunk id generation will work in the same way as before.
@@ -84,4 +85,10 @@ The default is to transfer all archives, including checkpoint archives.
 
 You could use the misc. archive filter options to limit which archives it will
 transfer, e.g. using the -a option. This is recommended for big
-repositories with multiple data sets to keep the runtime per invocation lower.
\ No newline at end of file
+repositories with multiple data sets to keep the runtime per invocation lower.
+
+For repository upgrades (e.g. from a borg 1.2 repo to a related borg 2.0 repo), usage is
+quite similar to the above::
+
+    borg --repo=DST_REPO transfer --other-repo=SRC_REPO --upgrader=From12To20
+

From 0264f8dc928905bccef8c23aa6e8daf5c12aef43 Mon Sep 17 00:00:00 2001
From: Thomas Waldmann <tw@waldmann-edv.de>
Date: Mon, 4 Jul 2022 14:53:31 +0200
Subject: [PATCH 102/160] fix benchmark tests

---
 src/borg/testsuite/benchmark.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/borg/testsuite/benchmark.py b/src/borg/testsuite/benchmark.py
index b23a7d800..cc21f19f6 100644
--- a/src/borg/testsuite/benchmark.py
+++ b/src/borg/testsuite/benchmark.py
@@ -26,7 +26,7 @@ def repo_url(request, tmpdir, monkeypatch):
     tmpdir.remove(rec=1)
 
 
-@pytest.fixture(params=["none", "repokey"])
+@pytest.fixture(params=["none", "repokey-aes-ocb"])
 def repo(request, cmd, repo_url):
     cmd(f'--repo={repo_url}', 'rcreate', '--encryption', request.param)
     return repo_url

From 5c8a5f111f5cf4a16ea72b76a5335a7b35259e18 Mon Sep 17 00:00:00 2001
From: Thomas Waldmann <tw@waldmann-edv.de>
Date: Mon, 4 Jul 2022 20:26:42 +0200
Subject: [PATCH 103/160] stop using libdeflate

borg2's new repo format does not need computing crc32 over big amounts of
(content) data any more (we now use xxh64 for that).

thus, having a quick crc32 implementation via libdeflate is not important
enough any more to rectify having libdeflate as a requirement.
---
 .github/workflows/ci.yml              |  4 +---
 .github/workflows/codeql-analysis.yml |  4 ++--
 Vagrantfile                           |  8 +++-----
 docs/installation.rst                 | 14 ++++++--------
 setup.py                              |  1 -
 src/borg/archiver.py                  | 12 ++----------
 src/borg/checksums.pyx                | 22 +++-------------------
 src/borg/testsuite/checksums.py       | 22 ----------------------
 8 files changed, 17 insertions(+), 70 deletions(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 89c1a1187..8ef2e8f65 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -67,7 +67,6 @@ jobs:
     env:
       # Configure pkg-config to use OpenSSL from Homebrew
       PKG_CONFIG_PATH: /usr/local/opt/openssl@1.1/lib/pkgconfig
-      BORG_LIBDEFLATE_PREFIX: /usr  # on ubuntu 20.04 pkgconfig does not find libdeflate
       TOXENV: ${{ matrix.toxenv }}
 
     runs-on: ${{ matrix.os }}
@@ -96,7 +95,7 @@ jobs:
       run: |
         sudo apt-get update
         sudo apt-get install -y pkg-config build-essential
-        sudo apt-get install -y libssl-dev libacl1-dev libxxhash-dev libdeflate-dev liblz4-dev libzstd-dev
+        sudo apt-get install -y libssl-dev libacl1-dev libxxhash-dev liblz4-dev libzstd-dev
         sudo apt-get install -y libfuse-dev fuse || true  # Required for Python llfuse module
         sudo apt-get install -y libfuse3-dev fuse3 || true  # Required for Python pyfuse3 module
 
@@ -106,7 +105,6 @@ jobs:
         brew install pkg-config || brew upgrade pkg-config
         brew install zstd || brew upgrade zstd
         brew install lz4 || brew upgrade lz4
-        brew install libdeflate || brew upgrade libdeflate
         brew install xxhash || brew upgrade xxhash
         brew install openssl@1.1 || brew upgrade openssl@1.1
         brew install --cask macfuse || brew upgrade --cask macfuse  # Required for Python llfuse module
diff --git a/.github/workflows/codeql-analysis.yml b/.github/workflows/codeql-analysis.yml
index 3caec9d3b..ba31216ca 100644
--- a/.github/workflows/codeql-analysis.yml
+++ b/.github/workflows/codeql-analysis.yml
@@ -28,7 +28,7 @@ jobs:
         # Learn more about CodeQL language support at https://git.io/codeql-language-support
 
     env:
-      BORG_LIBDEFLATE_PREFIX: /usr  # on ubuntu 20.04 pkgconfig does not find libdeflate
+      # nothing special right now
 
     steps:
     - name: Checkout repository
@@ -52,7 +52,7 @@ jobs:
       run: |
         sudo apt-get update
         sudo apt-get install -y pkg-config build-essential
-        sudo apt-get install -y libssl-dev libacl1-dev libxxhash-dev libdeflate-dev liblz4-dev libzstd-dev
+        sudo apt-get install -y libssl-dev libacl1-dev libxxhash-dev liblz4-dev libzstd-dev
     # Initializes the CodeQL tools for scanning.
     - name: Initialize CodeQL
       uses: github/codeql-action/init@v1
diff --git a/Vagrantfile b/Vagrantfile
index 10d3a4cd0..37d1572e9 100644
--- a/Vagrantfile
+++ b/Vagrantfile
@@ -15,7 +15,7 @@ def packages_debianoid(user)
     apt-get -y -qq update
     apt-get -y -qq dist-upgrade
     # for building borgbackup and dependencies:
-    apt install -y libssl-dev libacl1-dev libxxhash-dev libdeflate-dev liblz4-dev libzstd-dev pkg-config
+    apt install -y libssl-dev libacl1-dev libxxhash-dev liblz4-dev libzstd-dev pkg-config
     apt install -y libfuse-dev fuse || true
     apt install -y libfuse3-dev fuse3 || true
     apt install -y locales || true
@@ -29,7 +29,6 @@ def packages_debianoid(user)
     apt install -y zlib1g-dev libbz2-dev libncurses5-dev libreadline-dev liblzma-dev libsqlite3-dev libffi-dev
     # older debian / ubuntu have no .pc file for these, so we need to point at the lib/header location:
     echo 'export BORG_LIBXXHASH_PREFIX=/usr' >> ~vagrant/.bash_profile
-    echo 'export BORG_LIBDEFLATE_PREFIX=/usr' >> ~vagrant/.bash_profile
   EOF
 end
 
@@ -40,7 +39,7 @@ def packages_freebsd
     # install all the (security and other) updates, base system
     freebsd-update --not-running-from-cron fetch install
     # for building borgbackup and dependencies:
-    pkg install -y xxhash libdeflate liblz4 zstd pkgconf
+    pkg install -y xxhash liblz4 zstd pkgconf
     pkg install -y fusefs-libs || true
     pkg install -y fusefs-libs3 || true
     pkg install -y git bash  # fakeroot causes lots of troubles on freebsd
@@ -74,7 +73,6 @@ def packages_openbsd
     pkg_add bash
     chsh -s bash vagrant
     pkg_add xxhash
-    pkg_add libdeflate
     pkg_add lz4
     pkg_add zstd
     pkg_add git  # no fakeroot
@@ -119,7 +117,7 @@ def packages_darwin
     sudo softwareupdate --install --all
     which brew || CI=1 /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install.sh)"
     brew update > /dev/null
-    brew install pkg-config readline openssl@1.1 xxhash libdeflate zstd lz4 xz
+    brew install pkg-config readline openssl@1.1 xxhash zstd lz4 xz
     brew install --cask macfuse
     # brew upgrade  # upgrade everything (takes rather long)
     echo 'export PKG_CONFIG_PATH=/usr/local/opt/openssl@1.1/lib/pkgconfig' >> ~vagrant/.bash_profile
diff --git a/docs/installation.rst b/docs/installation.rst
index 60b05e45d..ce28b52f3 100644
--- a/docs/installation.rst
+++ b/docs/installation.rst
@@ -167,7 +167,6 @@ following dependencies first:
   - liblz4_ >= 1.7.0 (r129)
   - libzstd_ >= 1.3.0
   - libxxhash >= 0.8.1 (0.8.0 might work also)
-  - libdeflate >= 1.5
 * pkg-config (cli tool) and pkgconfig python package (borg uses these to
   discover header and library location - if it can't import pkgconfig and
   is not pointed to header/library locations via env vars [see setup.py],
@@ -202,7 +201,7 @@ Install the dependencies with development headers::
     sudo apt-get install python3 python3-dev python3-pip python3-virtualenv \
     libacl1-dev libacl1 \
     libssl-dev \
-    liblz4-dev libzstd-dev libxxhash-dev libdeflate-dev \
+    liblz4-dev libzstd-dev libxxhash-dev \
     build-essential \
     pkg-config python3-pkgconfig
     sudo apt-get install libfuse-dev fuse    # needed for llfuse
@@ -220,7 +219,7 @@ Install the dependencies with development headers::
     sudo dnf install python3 python3-devel python3-pip python3-virtualenv \
     libacl-devel libacl \
     openssl-devel \
-    lz4-devel libzstd-devel xxhash-devel libdeflate-devel \
+    lz4-devel libzstd-devel xxhash-devel \
     pkgconf python3-pkgconfig
     sudo dnf install gcc gcc-c++ redhat-rpm-config
     sudo dnf install fuse-devel fuse         # needed for llfuse
@@ -236,8 +235,7 @@ Install the dependencies automatically using zypper::
 Alternatively, you can enumerate all build dependencies in the command line::
 
     sudo zypper install python3 python3-devel \
-    libacl-devel openssl-devel \
-    libxxhash-devel libdeflate-devel \
+    libacl-devel openssl-devel libxxhash-devel \
     python3-Cython python3-Sphinx python3-msgpack-python python3-pkgconfig pkgconf \
     python3-pytest python3-setuptools python3-setuptools_scm \
     python3-sphinx_rtd_theme gcc gcc-c++
@@ -249,7 +247,7 @@ macOS
 When installing via Homebrew_, dependencies are installed automatically. To install
 dependencies manually::
 
-    brew install python3 openssl zstd lz4 xxhash libdeflate
+    brew install python3 openssl zstd lz4 xxhash
     brew install pkg-config
     pip3 install virtualenv pkgconfig
 
@@ -286,7 +284,7 @@ and commands to make FUSE work for using the mount command.
 
      pkg install -y python3 pkgconf
      pkg install openssl
-     pkg install liblz4 zstd xxhash libdeflate
+     pkg install liblz4 zstd xxhash
      pkg install fusefs-libs  # needed for llfuse
      pkg install -y git
      python3 -m ensurepip # to install pip for Python3
@@ -316,7 +314,7 @@ Use the Cygwin installer to install the dependencies::
 
     python39 python39-devel python39-pkgconfig
     python39-setuptools python39-pip python39-wheel python39-virtualenv
-    libssl-devel libxxhash-devel libdeflate-devel liblz4-devel libzstd-devel
+    libssl-devel libxxhash-devel liblz4-devel libzstd-devel
     binutils gcc-g++ git make openssh
 
 
diff --git a/setup.py b/setup.py
index 2d91a6a47..f962e2c49 100644
--- a/setup.py
+++ b/setup.py
@@ -186,7 +186,6 @@ if not on_rtd:
     checksums_ext_kwargs = members_appended(
         dict(sources=[checksums_source]),
         lib_ext_kwargs(pc, 'BORG_LIBXXHASH_PREFIX', 'xxhash', 'libxxhash', '>= 0.7.3'),
-        lib_ext_kwargs(pc, 'BORG_LIBDEFLATE_PREFIX', 'deflate', 'libdeflate', '>= 1.5'),
         dict(extra_compile_args=cflags),
     )
 
diff --git a/src/borg/archiver.py b/src/borg/archiver.py
index 3c141234f..f4f2ef355 100644
--- a/src/borg/archiver.py
+++ b/src/borg/archiver.py
@@ -715,21 +715,13 @@ class Archiver:
         ]:
             print(f"{spec:<24} {size:<10} {timeit(func, number=100):.3f}s")
 
-        import zlib
-        from .checksums import crc32, deflate_crc32, xxh64
+        from .checksums import crc32, xxh64
         print("Non-cryptographic checksums / hashes ===========================")
         size = "1GB"
         tests = [
             ("xxh64", lambda: xxh64(random_10M)),
+            ("crc32 (zlib)", lambda: crc32(random_10M)),
         ]
-        if crc32 is zlib.crc32:
-            tests.insert(0, ("crc32 (zlib, used)", lambda: crc32(random_10M)))
-            tests.insert(1, ("crc32 (libdeflate)", lambda: deflate_crc32(random_10M)))
-        elif crc32 is deflate_crc32:
-            tests.insert(0, ("crc32 (libdeflate, used)", lambda: crc32(random_10M)))
-            tests.insert(1, ("crc32 (zlib)", lambda: zlib.crc32(random_10M)))
-        else:
-            raise Error("crc32 benchmarking code missing")
         for spec, func in tests:
             print(f"{spec:<24} {size:<10} {timeit(func, number=100):.3f}s")
 
diff --git a/src/borg/checksums.pyx b/src/borg/checksums.pyx
index b3372b8c2..32a21770b 100644
--- a/src/borg/checksums.pyx
+++ b/src/borg/checksums.pyx
@@ -33,31 +33,15 @@ cdef extern from "xxhash.h":
     XXH64_hash_t XXH64_hashFromCanonical(const XXH64_canonical_t* src)
 
 
-cdef extern from "libdeflate.h":
-    uint32_t libdeflate_crc32(uint32_t crc, const void *buffer, size_t len)
-
-
 cdef Py_buffer ro_buffer(object data) except *:
     cdef Py_buffer view
     PyObject_GetBuffer(data, &view, PyBUF_SIMPLE)
     return view
 
 
-def deflate_crc32(data, value=0):
-    cdef Py_buffer data_buf = ro_buffer(data)
-    cdef uint32_t val = value
-    try:
-        return libdeflate_crc32(val, data_buf.buf, data_buf.len)
-    finally:
-        PyBuffer_Release(&data_buf)
-
-
-if is_darwin:
-    # macOS (darwin) has a highly optimized zlib.crc32 (Intel as well as Apple Silicon M1)
-    crc32 = zlib.crc32
-else:
-    # on Linux x64 (and maybe others), libdeflate_crc32 is faster than zlib.crc32
-    crc32 = deflate_crc32
+# borg 2.0's new repos do not compute crc32 over big amounts of data,
+# so speed does not matter much any more and we can just use zlib.crc32.
+crc32 = zlib.crc32
 
 
 def xxh64(data, seed=0):
diff --git a/src/borg/testsuite/checksums.py b/src/borg/testsuite/checksums.py
index 2513d7a50..2567fda8a 100644
--- a/src/borg/testsuite/checksums.py
+++ b/src/borg/testsuite/checksums.py
@@ -1,30 +1,8 @@
-import os
-import zlib
 from binascii import unhexlify
 
-import pytest
-
 from .. import checksums
 from ..helpers import bin_to_hex
 
-crc32_implementations = [checksums.deflate_crc32]
-
-
-@pytest.mark.parametrize('implementation', crc32_implementations)
-def test_crc32(implementation):
-    # This includes many critical values, like misc. length and misc. aligned start addresses.
-    data = os.urandom(300)
-    mv = memoryview(data)
-    initial_crc = 0x12345678
-    for start in range(0, 4):  # 4B / int32 alignment, head processing
-        for length in [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
-                       31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41,
-                       63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73,
-                       127, 128, 129, 130, 131, 132, 133, 134, 135,
-                       255, 256, 257, ]:
-            d = mv[start:start+length]
-            assert zlib.crc32(d, initial_crc) == implementation(d, initial_crc)
-
 
 def test_xxh64():
     assert bin_to_hex(checksums.xxh64(b'test', 123)) == '2b81b9401bef86cf'

From 350393c9fdd606dc430373503bfe3bf2697d7b38 Mon Sep 17 00:00:00 2001
From: Thomas Waldmann <tw@waldmann-edv.de>
Date: Mon, 4 Jul 2022 23:57:17 +0200
Subject: [PATCH 104/160] remove unused imports

---
 setup.py                         | 2 +-
 src/borg/_hashindex.c            | 1 -
 src/borg/archive.py              | 3 +--
 src/borg/chunker.pyx             | 2 +-
 src/borg/crypto/key.py           | 3 +--
 src/borg/crypto/keymanager.py    | 2 +-
 src/borg/crypto/low_level.pyx    | 1 -
 src/borg/hashindex.pyx           | 4 ----
 src/borg/helpers/checks.py       | 1 -
 src/borg/helpers/parseformat.py  | 2 +-
 src/borg/platform/linux.pyx      | 2 --
 src/borg/testsuite/__init__.py   | 1 -
 src/borg/testsuite/archiver.py   | 2 --
 src/borg/testsuite/hashindex.py  | 1 -
 src/borg/testsuite/helpers.py    | 1 -
 src/borg/testsuite/key.py        | 4 ----
 src/borg/testsuite/locking.py    | 1 -
 src/borg/testsuite/platform.py   | 1 -
 src/borg/testsuite/repository.py | 2 +-
 src/borg/upgrader.py             | 0
 20 files changed, 7 insertions(+), 29 deletions(-)
 delete mode 100644 src/borg/upgrader.py

diff --git a/setup.py b/setup.py
index 2d91a6a47..feed325ca 100644
--- a/setup.py
+++ b/setup.py
@@ -11,7 +11,7 @@ except ImportError:
     multiprocessing = None
 
 from setuptools.command.build_ext import build_ext
-from setuptools import setup, find_packages, Extension, Command
+from setuptools import setup, Extension, Command
 from setuptools.command.sdist import sdist
 
 try:
diff --git a/src/borg/_hashindex.c b/src/borg/_hashindex.c
index 7cd4cf31a..dd704d2de 100644
--- a/src/borg/_hashindex.c
+++ b/src/borg/_hashindex.c
@@ -1,4 +1,3 @@
-
 #include <assert.h>
 #include <errno.h>
 #include <stdio.h>
diff --git a/src/borg/archive.py b/src/borg/archive.py
index 2c49c18fd..584f5f030 100644
--- a/src/borg/archive.py
+++ b/src/borg/archive.py
@@ -1,7 +1,6 @@
 import base64
 import json
 import os
-import socket
 import stat
 import sys
 import time
@@ -32,7 +31,7 @@ from .helpers import HardLinkManager
 from .helpers import ChunkIteratorFileWrapper, open_item
 from .helpers import Error, IntegrityError, set_ec
 from .platform import uid2user, user2uid, gid2group, group2gid
-from .helpers import parse_timestamp, to_localtime
+from .helpers import parse_timestamp
 from .helpers import OutputTimestamp, format_timedelta, format_file_size, file_status, FileSize
 from .helpers import safe_encode, make_path_safe, remove_surrogates
 from .helpers import StableDict
diff --git a/src/borg/chunker.pyx b/src/borg/chunker.pyx
index ee9773be4..d9c31d3e3 100644
--- a/src/borg/chunker.pyx
+++ b/src/borg/chunker.pyx
@@ -6,7 +6,7 @@ import errno
 import os
 from collections import namedtuple
 
-from .constants import CH_DATA, CH_ALLOC, CH_HOLE, MAX_DATA_SIZE, zeros
+from .constants import CH_DATA, CH_ALLOC, CH_HOLE, zeros
 
 from libc.stdlib cimport free
 
diff --git a/src/borg/crypto/key.py b/src/borg/crypto/key.py
index cd1fd9324..94f824942 100644
--- a/src/borg/crypto/key.py
+++ b/src/borg/crypto/key.py
@@ -1,4 +1,3 @@
-import configparser
 import hmac
 import os
 import textwrap
@@ -26,7 +25,7 @@ from ..item import Key, EncryptedKey, want_bytes
 from ..platform import SaveFile
 
 from .nonces import NonceManager
-from .low_level import AES, bytes_to_long, long_to_bytes, bytes_to_int, num_cipher_blocks, hmac_sha256, blake2b_256, hkdf_hmac_sha512
+from .low_level import AES, bytes_to_int, num_cipher_blocks, hmac_sha256, blake2b_256, hkdf_hmac_sha512
 from .low_level import AES256_CTR_HMAC_SHA256, AES256_CTR_BLAKE2b, AES256_OCB, CHACHA20_POLY1305
 from . import low_level
 
diff --git a/src/borg/crypto/keymanager.py b/src/borg/crypto/keymanager.py
index db5eb23c7..715d451a1 100644
--- a/src/borg/crypto/keymanager.py
+++ b/src/borg/crypto/keymanager.py
@@ -7,7 +7,7 @@ from hashlib import sha256
 from ..helpers import Manifest, NoManifestError, Error, yes, bin_to_hex, dash_open
 from ..repository import Repository
 
-from .key import CHPOKeyfileKey, KeyfileNotFoundError, RepoKeyNotFoundError, KeyBlobStorage, identify_key
+from .key import CHPOKeyfileKey, RepoKeyNotFoundError, KeyBlobStorage, identify_key
 
 
 class UnencryptedRepo(Error):
diff --git a/src/borg/crypto/low_level.pyx b/src/borg/crypto/low_level.pyx
index d44160b50..c5b8c7c3f 100644
--- a/src/borg/crypto/low_level.pyx
+++ b/src/borg/crypto/low_level.pyx
@@ -40,7 +40,6 @@ from math import ceil
 
 from cpython cimport PyMem_Malloc, PyMem_Free
 from cpython.buffer cimport PyBUF_SIMPLE, PyObject_GetBuffer, PyBuffer_Release
-from cpython.bytes cimport PyBytes_FromStringAndSize
 
 API_VERSION = '1.3_01'
 
diff --git a/src/borg/hashindex.pyx b/src/borg/hashindex.pyx
index 3cb8d5a4d..15b59b5da 100644
--- a/src/borg/hashindex.pyx
+++ b/src/borg/hashindex.pyx
@@ -1,13 +1,9 @@
 # -*- coding: utf-8 -*-
 from collections import namedtuple
-import locale
-import os
 
 cimport cython
 from libc.stdint cimport uint32_t, UINT32_MAX, uint64_t
-from libc.errno cimport errno
 from libc.string cimport memcpy
-from cpython.exc cimport PyErr_SetFromErrnoWithFilename
 from cpython.buffer cimport PyBUF_SIMPLE, PyObject_GetBuffer, PyBuffer_Release
 from cpython.bytes cimport PyBytes_FromStringAndSize, PyBytes_CheckExact, PyBytes_GET_SIZE, PyBytes_AS_STRING
 
diff --git a/src/borg/helpers/checks.py b/src/borg/helpers/checks.py
index 316368b0c..26a6c0129 100644
--- a/src/borg/helpers/checks.py
+++ b/src/borg/helpers/checks.py
@@ -1,5 +1,4 @@
 import os
-import sys
 
 from .errors import Error
 from ..platformflags import is_win32, is_linux, is_freebsd, is_darwin
diff --git a/src/borg/helpers/parseformat.py b/src/borg/helpers/parseformat.py
index 808466776..a9d2ac960 100644
--- a/src/borg/helpers/parseformat.py
+++ b/src/borg/helpers/parseformat.py
@@ -20,7 +20,7 @@ logger = create_logger()
 from .errors import Error
 from .fs import get_keys_dir
 from .msgpack import Timestamp
-from .time import OutputTimestamp, format_time, to_localtime, safe_timestamp, safe_s
+from .time import OutputTimestamp, format_time, to_localtime, safe_timestamp
 from .. import __version__ as borg_version
 from .. import __version_tuple__ as borg_version_tuple
 from ..constants import *  # NOQA
diff --git a/src/borg/platform/linux.pyx b/src/borg/platform/linux.pyx
index 01fe409fb..5fc37680d 100644
--- a/src/borg/platform/linux.pyx
+++ b/src/borg/platform/linux.pyx
@@ -1,7 +1,6 @@
 import os
 import re
 import stat
-import subprocess
 
 from .posix import posix_acl_use_stored_uid_gid
 from .posix import user2uid, group2gid
@@ -17,7 +16,6 @@ except ImportError:
     SYNC_FILE_RANGE_LOADED = False
 
 from libc cimport errno
-from libc.stdint cimport int64_t
 
 API_VERSION = '1.2_05'
 
diff --git a/src/borg/testsuite/__init__.py b/src/borg/testsuite/__init__.py
index 307798e64..0ad942482 100644
--- a/src/borg/testsuite/__init__.py
+++ b/src/borg/testsuite/__init__.py
@@ -12,7 +12,6 @@ import sys
 import sysconfig
 import tempfile
 import time
-import uuid
 import unittest
 
 from ..xattr import get_all
diff --git a/src/borg/testsuite/archiver.py b/src/borg/testsuite/archiver.py
index d568d2a9c..4a29440d4 100644
--- a/src/borg/testsuite/archiver.py
+++ b/src/borg/testsuite/archiver.py
@@ -35,7 +35,6 @@ from ..archiver import Archiver, parse_storage_quota, PURE_PYTHON_MSGPACK_WARNIN
 from ..cache import Cache, LocalCache
 from ..chunker import has_seek_hole
 from ..constants import *  # NOQA
-from ..crypto.low_level import bytes_to_long, num_cipher_blocks
 from ..crypto.key import FlexiKey, AESOCBRepoKey, AESOCBKeyfileKey, CHPOKeyfileKey, Passphrase, TAMRequiredError
 from ..crypto.keymanager import RepoIdMismatch, NotABorgKeyFile
 from ..crypto.file_integrity import FileIntegrityError
@@ -43,7 +42,6 @@ from ..helpers import Location, get_security_dir
 from ..helpers import Manifest, MandatoryFeatureUnsupported
 from ..helpers import EXIT_SUCCESS, EXIT_WARNING, EXIT_ERROR
 from ..helpers import bin_to_hex
-from ..helpers import MAX_S
 from ..helpers import msgpack
 from ..helpers import flags_noatime, flags_normal
 from ..nanorst import RstToTextLazy, rst_to_terminal
diff --git a/src/borg/testsuite/hashindex.py b/src/borg/testsuite/hashindex.py
index b05ff77fd..b98444c3a 100644
--- a/src/borg/testsuite/hashindex.py
+++ b/src/borg/testsuite/hashindex.py
@@ -9,7 +9,6 @@ import tempfile
 import zlib
 
 from ..hashindex import NSIndex, ChunkIndex, ChunkIndexEntry
-from .. import hashindex
 from ..crypto.file_integrity import IntegrityCheckedFile, FileIntegrityError
 from . import BaseTestCase, unopened_tempfile
 
diff --git a/src/borg/testsuite/helpers.py b/src/borg/testsuite/helpers.py
index ca2b89bf1..7a532c9d6 100644
--- a/src/borg/testsuite/helpers.py
+++ b/src/borg/testsuite/helpers.py
@@ -7,7 +7,6 @@ import sys
 from argparse import ArgumentTypeError
 from datetime import datetime, timezone, timedelta
 from io import StringIO, BytesIO
-from time import sleep
 
 import pytest
 
diff --git a/src/borg/testsuite/key.py b/src/borg/testsuite/key.py
index b202d1078..2b69e73b0 100644
--- a/src/borg/testsuite/key.py
+++ b/src/borg/testsuite/key.py
@@ -1,5 +1,3 @@
-import getpass
-import os.path
 import re
 import tempfile
 from binascii import hexlify, unhexlify, a2b_base64
@@ -15,12 +13,10 @@ from ..crypto.key import Blake2AESOCBRepoKey, Blake2AESOCBKeyfileKey, Blake2CHPO
 from ..crypto.key import ID_HMAC_SHA_256, ID_BLAKE2b_256
 from ..crypto.key import TAMRequiredError, TAMInvalid, TAMUnsupportedSuiteError, UnsupportedManifestError, UnsupportedKeyFormatError
 from ..crypto.key import identify_key
-from ..crypto.low_level import bytes_to_long
 from ..crypto.low_level import IntegrityError as IntegrityErrorBase
 from ..helpers import IntegrityError
 from ..helpers import Location
 from ..helpers import StableDict
-from ..helpers import get_security_dir
 from ..helpers import msgpack
 from ..constants import KEY_ALGORITHMS
 
diff --git a/src/borg/testsuite/locking.py b/src/borg/testsuite/locking.py
index 7a0f219cd..656909ac5 100644
--- a/src/borg/testsuite/locking.py
+++ b/src/borg/testsuite/locking.py
@@ -5,7 +5,6 @@ from traceback import format_exc
 
 import pytest
 
-from ..helpers import daemonize
 from ..platform import get_process_id, process_alive
 from ..locking import TimeoutTimer, ExclusiveLock, Lock, LockRoster, \
                       ADD, REMOVE, SHARED, EXCLUSIVE, LockTimeout, NotLocked, NotMyLock
diff --git a/src/borg/testsuite/platform.py b/src/borg/testsuite/platform.py
index 659e4376e..35d444845 100644
--- a/src/borg/testsuite/platform.py
+++ b/src/borg/testsuite/platform.py
@@ -1,6 +1,5 @@
 import functools
 import os
-import random
 import shutil
 import sys
 import tempfile
diff --git a/src/borg/testsuite/repository.py b/src/borg/testsuite/repository.py
index a794f98ec..9248e5d8f 100644
--- a/src/borg/testsuite/repository.py
+++ b/src/borg/testsuite/repository.py
@@ -13,7 +13,7 @@ from ..helpers import Location
 from ..helpers import IntegrityError
 from ..helpers import msgpack
 from ..locking import Lock, LockFailed
-from ..remote import RemoteRepository, InvalidRPCMethod, PathNotAllowed, ConnectionClosedWithHint, handle_remote_line
+from ..remote import RemoteRepository, InvalidRPCMethod, PathNotAllowed, handle_remote_line
 from ..repository import Repository, LoggedIO, MAGIC, MAX_DATA_SIZE, TAG_DELETE, TAG_PUT2, TAG_PUT, TAG_COMMIT
 from . import BaseTestCase
 from .hashindex import H
diff --git a/src/borg/upgrader.py b/src/borg/upgrader.py
deleted file mode 100644
index e69de29bb..000000000

From f04b2bd25550b95db776f865c645e8dad8660899 Mon Sep 17 00:00:00 2001
From: Thomas Waldmann <tw@waldmann-edv.de>
Date: Tue, 5 Jul 2022 00:08:51 +0200
Subject: [PATCH 105/160] remove coding: from cython files, utf-8 is default
 encoding

---
 src/borg/chunker.pyx   | 2 --
 src/borg/hashindex.pyx | 1 -
 2 files changed, 3 deletions(-)

diff --git a/src/borg/chunker.pyx b/src/borg/chunker.pyx
index d9c31d3e3..f11e93b2d 100644
--- a/src/borg/chunker.pyx
+++ b/src/borg/chunker.pyx
@@ -1,5 +1,3 @@
-# -*- coding: utf-8 -*-
-
 API_VERSION = '1.2_01'
 
 import errno
diff --git a/src/borg/hashindex.pyx b/src/borg/hashindex.pyx
index 15b59b5da..3df89f365 100644
--- a/src/borg/hashindex.pyx
+++ b/src/borg/hashindex.pyx
@@ -1,4 +1,3 @@
-# -*- coding: utf-8 -*-
 from collections import namedtuple
 
 cimport cython

From ff46a03b4212fab583f13ebf70ca608d268f06c4 Mon Sep 17 00:00:00 2001
From: Thomas Waldmann <tw@waldmann-edv.de>
Date: Tue, 5 Jul 2022 00:16:48 +0200
Subject: [PATCH 106/160] use language_level = 3str for cython

this will be the default in cython 3.
---
 setup.py | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/setup.py b/setup.py
index feed325ca..b0b380354 100644
--- a/setup.py
+++ b/setup.py
@@ -225,9 +225,7 @@ if not on_rtd:
 
     if cythonize and cythonizing:
         cython_opts = dict(
-            # default language_level will be '3str' starting from Cython 3.0.0,
-            # but old cython versions (< 0.29) do not know that, thus we use 3 for now.
-            compiler_directives={'language_level': 3},
+            compiler_directives={'language_level': '3str'},
         )
         if not is_win32:
             # compile .pyx extensions to .c in parallel, does not work on windows

From dbe62b8074d94788638ed19f2b9cdc64d0c69545 Mon Sep 17 00:00:00 2001
From: Thomas Waldmann <tw@waldmann-edv.de>
Date: Tue, 5 Jul 2022 00:21:03 +0200
Subject: [PATCH 107/160] docs: replaced tabs by spaces

---
 docs/deployment/hosting-repositories.rst | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/docs/deployment/hosting-repositories.rst b/docs/deployment/hosting-repositories.rst
index fd534e734..24dc5213d 100644
--- a/docs/deployment/hosting-repositories.rst
+++ b/docs/deployment/hosting-repositories.rst
@@ -37,11 +37,11 @@ SSH access to safe operations only.
 
 .. warning::
 
-	If this file should be automatically updated (e.g. by a web console),
-	pay **utmost attention** to sanitizing user input. Strip all whitespace
-	around the user-supplied key, ensure that it **only** contains ASCII
-	with no control characters and that it consists of three parts separated
-	by a single space. Ensure that no newlines are contained within the key.
+    If this file should be automatically updated (e.g. by a web console),
+    pay **utmost attention** to sanitizing user input. Strip all whitespace
+    around the user-supplied key, ensure that it **only** contains ASCII
+    with no control characters and that it consists of three parts separated
+    by a single space. Ensure that no newlines are contained within the key.
 
 The ``restrict`` keyword enables all restrictions, i.e. disables port, agent
 and X11 forwarding, as well as disabling PTY allocation and execution of ~/.ssh/rc.
@@ -59,7 +59,7 @@ which allows for encryption.
 **Storage quotas** can be enabled by adding the ``--storage-quota`` option
 to the ``borg serve`` command line::
 
-	restrict,command="borg serve --storage-quota 20G ..." ...
+    restrict,command="borg serve --storage-quota 20G ..." ...
 
 The storage quotas of repositories are completely independent. If a
 client is able to access multiple repositories, each repository

From dbb63f874bb50b5978f56af0580fcb05a729973c Mon Sep 17 00:00:00 2001
From: Thomas Waldmann <tw@waldmann-edv.de>
Date: Tue, 5 Jul 2022 00:38:37 +0200
Subject: [PATCH 108/160] docs: fix rst literal blocks

---
 docs/development.rst    | 2 ++
 docs/usage/compact.rst  | 1 +
 docs/usage/create.rst   | 1 +
 docs/usage/delete.rst   | 1 +
 docs/usage/diff.rst     | 1 +
 docs/usage/extract.rst  | 1 +
 docs/usage/info.rst     | 1 +
 docs/usage/list.rst     | 1 +
 docs/usage/notes.rst    | 1 +
 docs/usage/rcreate.rst  | 1 +
 docs/usage/rdelete.rst  | 1 +
 docs/usage/recreate.rst | 1 +
 docs/usage/rename.rst   | 1 +
 docs/usage/rinfo.rst    | 1 +
 docs/usage/transfer.rst | 1 +
 15 files changed, 16 insertions(+)

diff --git a/docs/development.rst b/docs/development.rst
index 5eeaae83b..5051829d9 100644
--- a/docs/development.rst
+++ b/docs/development.rst
@@ -349,11 +349,13 @@ Checklist:
     scripts/sdist-sign X.Y.Z
     scripts/upload-pypi X.Y.Z test
     scripts/upload-pypi X.Y.Z
+
 - Put binaries into dist/borg-OSNAME and sign them:
 
   ::
 
     scripts/sign-binaries 201912312359
+
 - Close the release milestone on GitHub.
 - `Update borgbackup.org
   <https://github.com/borgbackup/borgbackup.github.io/pull/53/files>`_ with the
diff --git a/docs/usage/compact.rst b/docs/usage/compact.rst
index 6a3a15ad0..3a1389a67 100644
--- a/docs/usage/compact.rst
+++ b/docs/usage/compact.rst
@@ -6,3 +6,4 @@ Examples
 
     # compact segments and free repo disk space
     $ borg compact
+
diff --git a/docs/usage/create.rst b/docs/usage/create.rst
index 9d88b5469..a64d63b96 100644
--- a/docs/usage/create.rst
+++ b/docs/usage/create.rst
@@ -83,3 +83,4 @@ Examples
         --paths-from-stdin \
         --paths-delimiter "\0" \
         smallfiles-handle-newline
+
diff --git a/docs/usage/delete.rst b/docs/usage/delete.rst
index 56fc6e4e8..d62ef4927 100644
--- a/docs/usage/delete.rst
+++ b/docs/usage/delete.rst
@@ -17,3 +17,4 @@ Examples
 
     # see what would be deleted if delete was run without --dry-run
     $ borg delete --list --dry-run -a '*-May-*'
+
diff --git a/docs/usage/diff.rst b/docs/usage/diff.rst
index c758aceff..c372c3c06 100644
--- a/docs/usage/diff.rst
+++ b/docs/usage/diff.rst
@@ -15,3 +15,4 @@ Examples
     {"path": "file2", "changes": [{"type": "modified", "added": 135, "removed": 252}]}
     {"path": "file4", "changes": [{"type": "added", "size": 0}]}
     {"path": "file3", "changes": [{"type": "removed", "size": 0}]}
+
diff --git a/docs/usage/extract.rst b/docs/usage/extract.rst
index 1d53fb338..95703eaf0 100644
--- a/docs/usage/extract.rst
+++ b/docs/usage/extract.rst
@@ -21,3 +21,4 @@ Examples
 
     # Restore a raw device (must not be active/in use/mounted at that time)
     $ borg extract --stdout my-sdx | dd of=/dev/sdx bs=10M
+
diff --git a/docs/usage/info.rst b/docs/usage/info.rst
index 36aa623fa..b248aaeeb 100644
--- a/docs/usage/info.rst
+++ b/docs/usage/info.rst
@@ -18,3 +18,4 @@ Examples
     Number of files: 244
     Original size: 13.80 MB
     Deduplicated size: 531 B
+
diff --git a/docs/usage/list.rst b/docs/usage/list.rst
index 7fdc8d5d4..e168faf46 100644
--- a/docs/usage/list.rst
+++ b/docs/usage/list.rst
@@ -35,3 +35,4 @@ Examples
     -rw-rw-r-- user   user    1416192 Sun, 2015-02-01 11:00:00 code/myproject/file.ext
     -rw-rw-r-- user   user    1416192 Sun, 2015-02-01 11:00:00 code/myproject/file.text
     ...
+
diff --git a/docs/usage/notes.rst b/docs/usage/notes.rst
index 7ecdcdca4..b4e1637a5 100644
--- a/docs/usage/notes.rst
+++ b/docs/usage/notes.rst
@@ -333,3 +333,4 @@ When running Borg using an automated script, ``ssh`` might still ask for a passw
 even if there is an SSH key for the target server. Use this to make scripts more robust::
 
     export BORG_RSH='ssh -oBatchMode=yes'
+
diff --git a/docs/usage/rcreate.rst b/docs/usage/rcreate.rst
index 967387b01..985c29c34 100644
--- a/docs/usage/rcreate.rst
+++ b/docs/usage/rcreate.rst
@@ -23,3 +23,4 @@ Examples
     $ borg rcreate --encryption=repokey-aes-ocb
     # keyfile: stores the (encrypted) key into ~/.config/borg/keys/
     $ borg rcreate --encryption=keyfile-aes-ocb
+
diff --git a/docs/usage/rdelete.rst b/docs/usage/rdelete.rst
index ee189f2cc..e7b3acdda 100644
--- a/docs/usage/rdelete.rst
+++ b/docs/usage/rdelete.rst
@@ -11,3 +11,4 @@ Examples
     root-2016-02-15                      Mon, 2016-02-15 19:36:29
     newname                              Mon, 2016-02-15 19:50:19
     Type 'YES' if you understand this and want to continue: YES
+
diff --git a/docs/usage/recreate.rst b/docs/usage/recreate.rst
index 7f520acf2..c10df4ae5 100644
--- a/docs/usage/recreate.rst
+++ b/docs/usage/recreate.rst
@@ -27,3 +27,4 @@ Examples
     Fingerprint: ...
     Comment: This is a better comment
     ...
+
diff --git a/docs/usage/rename.rst b/docs/usage/rename.rst
index a4a9bc9ee..2fb046726 100644
--- a/docs/usage/rename.rst
+++ b/docs/usage/rename.rst
@@ -11,3 +11,4 @@ Examples
     $ borg rename archivename newname
     $ borg rlist
     newname                              Mon, 2016-02-15 19:50:19
+
diff --git a/docs/usage/rinfo.rst b/docs/usage/rinfo.rst
index 0b1097207..c2d09cb40 100644
--- a/docs/usage/rinfo.rst
+++ b/docs/usage/rinfo.rst
@@ -14,3 +14,4 @@ Examples
     Deduplicated size: 30.38 MB
     Unique chunks: 654
     Total chunks: 3302
+
diff --git a/docs/usage/transfer.rst b/docs/usage/transfer.rst
index 45f370b8c..cab2d2a62 100644
--- a/docs/usage/transfer.rst
+++ b/docs/usage/transfer.rst
@@ -29,3 +29,4 @@ Examples
     # 4. Check if we have everything (same as 2.):
     $ borg --repo       ssh://borg2@borgbackup/./tests/b20 transfer \
            --other-repo ssh://borg2@borgbackup/./tests/b12 --dry-run
+

From 0dc25000a904b8fc869dabc97316d0b7cec07b97 Mon Sep 17 00:00:00 2001
From: Thomas Waldmann <tw@waldmann-edv.de>
Date: Tue, 5 Jul 2022 02:38:09 +0200
Subject: [PATCH 109/160] recreate: consider level for recompression, fixes
 #6698, fixes #3622

---
 src/borg/archive.py            | 5 +++--
 src/borg/archiver.py           | 5 ++---
 src/borg/compress.pyx          | 9 ++++++---
 src/borg/testsuite/compress.py | 4 ++--
 4 files changed, 13 insertions(+), 10 deletions(-)

diff --git a/src/borg/archive.py b/src/borg/archive.py
index 2c49c18fd..c2191ba15 100644
--- a/src/borg/archive.py
+++ b/src/borg/archive.py
@@ -2080,8 +2080,9 @@ class ArchiveRecreater:
         if self.recompress and not self.always_recompress and chunk_id in self.cache.chunks:
             # Check if this chunk is already compressed the way we want it
             old_chunk = self.key.decrypt(chunk_id, self.repository.get(chunk_id), decompress=False)
-            if Compressor.detect(old_chunk).name == self.key.compressor.decide(data).name:
-                # Stored chunk has the same compression we wanted
+            compressor_cls, level = Compressor.detect(old_chunk)
+            if compressor_cls.name == self.key.compressor.decide(data).name and level == self.key.compressor.level:
+                # Stored chunk has the same compression method and level as we wanted
                 overwrite = False
         chunk_entry = self.cache.add_chunk(chunk_id, data, target.stats, overwrite=overwrite, wait=False)
         self.cache.repository.async_response(wait=False)
diff --git a/src/borg/archiver.py b/src/borg/archiver.py
index 3c141234f..45ebe71b9 100644
--- a/src/borg/archiver.py
+++ b/src/borg/archiver.py
@@ -4809,9 +4809,8 @@ class Archiver:
                                    help='recompress data chunks according to `MODE` and ``--compression``. '
                                         'Possible modes are '
                                         '`if-different`: recompress if current compression is with a different '
-                                        'compression algorithm (the level is not considered); '
-                                        '`always`: recompress even if current compression is with the same '
-                                        'compression algorithm (use this to change the compression level); and '
+                                        'compression algorithm or different level; '
+                                        '`always`: recompress unconditionally; and '
                                         '`never`: do not recompress (use this option to explicitly prevent '
                                         'recompression). '
                                         'If no MODE is given, `if-different` will be used. '
diff --git a/src/borg/compress.pyx b/src/borg/compress.pyx
index c63a04df3..824b11402 100644
--- a/src/borg/compress.pyx
+++ b/src/borg/compress.pyx
@@ -66,6 +66,7 @@ cdef class CompressorBase:
 
     def __init__(self, level=255, **kwargs):
         assert 0 <= level <= 255
+        self.level = level
         if self.ID is not None:
             self.id_level = self.ID + bytes((level, ))  # level 255 means "unknown level"
             assert len(self.id_level) == 2
@@ -539,7 +540,8 @@ class ObfuscateSize(CompressorBase):
         compr_size = self.header_fmt.unpack(obfuscated_data[0:self.header_len])[0]
         compressed_data = obfuscated_data[self.header_len:self.header_len+compr_size]
         if self.compressor is None:
-            self.compressor = Compressor.detect(compressed_data)()
+            compressor_cls = Compressor.detect(compressed_data)[0]
+            self.compressor = compressor_cls()
         return self.compressor.decompress(compressed_data)  # decompress data
 
 
@@ -578,15 +580,16 @@ class Compressor:
         return self.compressor.compress(data)
 
     def decompress(self, data):
-        compressor_cls = self.detect(data)
+        compressor_cls = self.detect(data)[0]
         return compressor_cls(**self.params).decompress(data)
 
     @staticmethod
     def detect(data):
         hdr = bytes(data[:2])  # detect() does not work with memoryview
+        level = hdr[1]  # usually the level, but not for zlib_legacy
         for cls in COMPRESSOR_LIST:
             if cls.detect(hdr):
-                return cls
+                return cls, (255 if cls.name == 'zlib_legacy' else level)
         else:
             raise ValueError('No decompressor for this data found: %r.', data[:2])
 
diff --git a/src/borg/testsuite/compress.py b/src/borg/testsuite/compress.py
index 3e3730b22..4d6cdafc8 100644
--- a/src/borg/testsuite/compress.py
+++ b/src/borg/testsuite/compress.py
@@ -133,11 +133,11 @@ def test_auto():
     compressed_lz4 = compressor_lz4.compress(data)
     compressed_zlib = compressor_zlib.compress(data)
     ratio = len(compressed_zlib) / len(compressed_lz4)
-    assert Compressor.detect(compressed_auto_zlib) == ZLIB if ratio < 0.99 else LZ4
+    assert Compressor.detect(compressed_auto_zlib)[0] == ZLIB if ratio < 0.99 else LZ4
 
     data = b'\x00\xb8\xa3\xa2-O\xe1i\xb6\x12\x03\xc21\xf3\x8a\xf78\\\x01\xa5b\x07\x95\xbeE\xf8\xa3\x9ahm\xb1~'
     compressed = compressor_auto_zlib.compress(data)
-    assert Compressor.detect(compressed) == CNONE
+    assert Compressor.detect(compressed)[0] == CNONE
 
 
 def test_obfuscate():

From 5e0c4a8fd4e6ecb17fc4cdf4f042fbcaff4a0fb1 Mon Sep 17 00:00:00 2001
From: Thomas Waldmann <tw@waldmann-edv.de>
Date: Tue, 5 Jul 2022 22:27:08 +0200
Subject: [PATCH 110/160] document hlid, fixes #2388

---
 docs/internals/data-structures.rst | 26 ++++++++++++++++++++++++++
 1 file changed, 26 insertions(+)

diff --git a/docs/internals/data-structures.rst b/docs/internals/data-structures.rst
index b494fde50..9b0efd7d0 100644
--- a/docs/internals/data-structures.rst
+++ b/docs/internals/data-structures.rst
@@ -568,6 +568,7 @@ dictionary created by the ``Item`` class that contains:
 * gid
 * mode (item type + permissions)
 * source (for symlinks)
+* hlid (for hardlinks)
 * rdev (for device files)
 * mtime, atime, ctime in nanoseconds
 * xattrs
@@ -1246,3 +1247,28 @@ For example, using 1.1 on a repository, noticing corruption or similar issues an
 ``borg-1.0 check --repair``, which rewrites the index and hints, results in this situation.
 Borg 1.1 would erroneously report checksum errors in the hints and/or index files and trigger
 an automatic rebuild of these files.
+
+HardLinkManager and the hlid concept
+------------------------------------
+
+Dealing with hard links needs some extra care, implemented in borg within the HardLinkManager
+class:
+
+- At archive creation time, fs items with st_nlink > 1 indicate that they are a member of
+  a group of hardlinks all pointing to the same inode. For such fs items, the archived item
+  includes a hlid attribute (hardlink id), which is computed like H(st_dev, st_ino). Thus,
+  if archived items have the same hlid value, they pointed to the same inode and form a
+  group of hardlinks. Besides that, nothing special is done for any member of the group
+  of hardlinks, meaning that e.g. for regular files, each archived item will have a
+  chunks list.
+- At extraction time, the presence of a hlid attribute indicates that there might be more
+  hardlinks coming, pointing to the same content (inode), thus borg will remember the "hlid
+  to extracted path" mapping, so it will know the correct path for extracting (hardlinking)
+  the next hardlink of that group / with the same hlid.
+- This symmetric approach (each item has all the information, e.g. the chunks list)
+  simplifies dealing with such items a lot, especially for partial extraction, for the
+  FUSE filesystem, etc.
+- This is different from the asymmetric approach of old borg versions (< 2.0) and also from
+  tar which have the concept of a main item (first hardlink, has the content) and content-less
+  secondary items with by-name back references for each subsequent hardlink, causing lots
+  of complications when dealing with them.

From a1acc00a9008234d4b67b02e7a5d46dfd399b4e0 Mon Sep 17 00:00:00 2001
From: Thomas Waldmann <tw@waldmann-edv.de>
Date: Wed, 6 Jul 2022 14:20:36 +0200
Subject: [PATCH 111/160] codeql: empty env section is invalid

---
 .github/workflows/codeql-analysis.yml | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/.github/workflows/codeql-analysis.yml b/.github/workflows/codeql-analysis.yml
index ba31216ca..f38dcf0f8 100644
--- a/.github/workflows/codeql-analysis.yml
+++ b/.github/workflows/codeql-analysis.yml
@@ -27,9 +27,6 @@ jobs:
         # CodeQL supports [ 'cpp', 'csharp', 'go', 'java', 'javascript', 'python', 'ruby' ]
         # Learn more about CodeQL language support at https://git.io/codeql-language-support
 
-    env:
-      # nothing special right now
-
     steps:
     - name: Checkout repository
       uses: actions/checkout@v2

From adb1c362155b2fe6123c428ff102853f4d66def4 Mon Sep 17 00:00:00 2001
From: Andrey Bienkowski <hexagon-recursion@posteo.net>
Date: Wed, 2 Mar 2022 06:19:33 +0300
Subject: [PATCH 112/160] black integration

---
 .github/workflows/black.yaml | 12 ++++++++++++
 pyproject.toml               |  4 ++++
 setup.cfg                    |  3 ++-
 src/borg/constants.py        |  6 +++++-
 4 files changed, 23 insertions(+), 2 deletions(-)
 create mode 100644 .github/workflows/black.yaml

diff --git a/.github/workflows/black.yaml b/.github/workflows/black.yaml
new file mode 100644
index 000000000..29e2b6d0e
--- /dev/null
+++ b/.github/workflows/black.yaml
@@ -0,0 +1,12 @@
+# https://black.readthedocs.io/en/stable/integrations/github_actions.html#usage
+
+name: Lint
+
+on: [push, pull_request]
+
+jobs:
+  lint:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - uses: psf/black@stable
diff --git a/pyproject.toml b/pyproject.toml
index 9261fbe8b..2a4838472 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -4,3 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [tool.setuptools_scm]
 write_to = "src/borg/_version.py"
+
+[tool.black]
+line-length = 120
+skip-magic-trailing-comma = true
diff --git a/setup.cfg b/setup.cfg
index 6e6e70c6c..0f7939da2 100644
--- a/setup.cfg
+++ b/setup.cfg
@@ -106,7 +106,8 @@ markers =
 #   W504 line break after binary operator
 
 # borg code style guidelines:
-ignore = E226, W503
+# Ignoring E203 due to https://github.com/PyCQA/pycodestyle/issues/373
+ignore = E226, W503, E203
 
 # Code style violation exceptions:
 # please note that the values are adjusted so that they do not cause failures
diff --git a/src/borg/constants.py b/src/borg/constants.py
index 19f9ba7f0..ff7840299 100644
--- a/src/borg/constants.py
+++ b/src/borg/constants.py
@@ -1,18 +1,22 @@
 # this set must be kept complete, otherwise the RobustUnpacker might malfunction:
+# fmt: off
 ITEM_KEYS = frozenset(['path', 'source', 'rdev', 'chunks', 'chunks_healthy', 'hardlink_master', 'hlid',
                        'mode', 'user', 'group', 'uid', 'gid', 'mtime', 'atime', 'ctime', 'birthtime', 'size',
                        'xattrs', 'bsdflags', 'acl_nfs4', 'acl_access', 'acl_default', 'acl_extended',
                        'part'])
+# fmt: on
 
 # this is the set of keys that are always present in items:
 REQUIRED_ITEM_KEYS = frozenset(['path', 'mtime', ])
 
 # this set must be kept complete, otherwise rebuild_manifest might malfunction:
+# fmt: off
 ARCHIVE_KEYS = frozenset(['version', 'name', 'items', 'cmdline', 'hostname', 'username', 'time', 'time_end',
                           'comment', 'chunker_params',
                           'recreate_cmdline',
                           'recreate_source_id', 'recreate_args', 'recreate_partial_chunks',  # used in 1.1.0b1 .. b2
-                          'size', 'nfiles', 'size_parts', 'nfiles_parts', ])
+                          'size', 'nfiles', 'size_parts', 'nfiles_parts'])
+# fmt: on
 
 # this is the set of keys that are always present in archives:
 REQUIRED_ARCHIVE_KEYS = frozenset(['version', 'name', 'items', 'cmdline', 'time', ])

From 7f8f6711024fae68a5b2d54b34cdf249f46368a5 Mon Sep 17 00:00:00 2001
From: Thomas Waldmann <tw@waldmann-edv.de>
Date: Wed, 6 Jul 2022 16:24:57 +0200
Subject: [PATCH 113/160] add requirements.d/codestyle.txt with the preferred
 black version

---
 requirements.d/codestyle.txt | 1 +
 1 file changed, 1 insertion(+)
 create mode 100644 requirements.d/codestyle.txt

diff --git a/requirements.d/codestyle.txt b/requirements.d/codestyle.txt
new file mode 100644
index 000000000..b173f0123
--- /dev/null
+++ b/requirements.d/codestyle.txt
@@ -0,0 +1 @@
+black==22.6.0

From 7957af562d5ce8266b177039783be4dc8bdd7898 Mon Sep 17 00:00:00 2001
From: Thomas Waldmann <tw@waldmann-edv.de>
Date: Wed, 6 Jul 2022 15:37:27 +0200
Subject: [PATCH 114/160] blacken all the code

https://black.readthedocs.io/
---
 conftest.py                                   |   21 +-
 docs/conf.py                                  |  148 +-
 scripts/errorlist.py                          |    4 +-
 scripts/glibc_check.py                        |   21 +-
 scripts/hash_sizes.py                         |   19 +-
 setup.py                                      |  142 +-
 setup_docs.py                                 |  380 +-
 src/borg/__init__.py                          |    6 +-
 src/borg/__main__.py                          |    7 +-
 src/borg/archive.py                           |  816 +--
 src/borg/archiver.py                          | 4193 ++++++++------
 src/borg/cache.py                             |  533 +-
 src/borg/constants.py                         |   38 +-
 src/borg/crypto/file_integrity.py             |   41 +-
 src/borg/crypto/key.py                        |  294 +-
 src/borg/crypto/keymanager.py                 |   92 +-
 src/borg/crypto/nonces.py                     |    8 +-
 src/borg/fuse.py                              |  213 +-
 src/borg/fuse_impl.py                         |   10 +-
 src/borg/helpers/__init__.py                  |    2 +-
 src/borg/helpers/checks.py                    |   13 +-
 src/borg/helpers/datastruct.py                |    5 +-
 src/borg/helpers/errors.py                    |    2 +
 src/borg/helpers/fs.py                        |   94 +-
 src/borg/helpers/manifest.py                  |   91 +-
 src/borg/helpers/misc.py                      |  103 +-
 src/borg/helpers/msgpack.py                   |  100 +-
 src/borg/helpers/parseformat.py               |  548 +-
 src/borg/helpers/passphrase.py                |   66 +-
 src/borg/helpers/process.py                   |   88 +-
 src/borg/helpers/progress.py                  |   29 +-
 src/borg/helpers/time.py                      |   38 +-
 src/borg/helpers/yes.py                       |   55 +-
 src/borg/locking.py                           |   39 +-
 src/borg/logger.py                            |   64 +-
 src/borg/lrucache.py                          |    4 +-
 src/borg/nanorst.py                           |  128 +-
 src/borg/patterns.py                          |   84 +-
 src/borg/platform/__init__.py                 |    1 +
 src/borg/platform/base.py                     |   37 +-
 src/borg/platform/xattr.py                    |   11 +-
 src/borg/platformflags.py                     |    8 +-
 src/borg/remote.py                            |  590 +-
 src/borg/repository.py                        |  530 +-
 src/borg/selftest.py                          |   23 +-
 src/borg/shellpattern.py                      |    2 +-
 src/borg/testsuite/__init__.py                |   67 +-
 src/borg/testsuite/archive.py                 |  153 +-
 src/borg/testsuite/archiver.py                | 4829 +++++++++--------
 src/borg/testsuite/benchmark.py               |   53 +-
 src/borg/testsuite/cache.py                   |  196 +-
 src/borg/testsuite/checksums.py               |   26 +-
 src/borg/testsuite/chunker.py                 |  122 +-
 src/borg/testsuite/chunker_pytest.py          |   91 +-
 src/borg/testsuite/chunker_slow.py            |    7 +-
 src/borg/testsuite/compress.py                |   99 +-
 src/borg/testsuite/crypto.py                  |  241 +-
 .../testsuite/efficient_collection_queue.py   |   24 +-
 src/borg/testsuite/file_integrity.py          |  109 +-
 src/borg/testsuite/hashindex.py               |   68 +-
 src/borg/testsuite/helpers.py                 |  872 +--
 src/borg/testsuite/item.py                    |   75 +-
 src/borg/testsuite/key.py                     |  233 +-
 src/borg/testsuite/locking.py                 |   88 +-
 src/borg/testsuite/logger.py                  |   15 +-
 src/borg/testsuite/lrucache.py                |   33 +-
 src/borg/testsuite/nanorst.py                 |   20 +-
 src/borg/testsuite/nonces.py                  |   29 +-
 src/borg/testsuite/patterns.py                |  649 ++-
 src/borg/testsuite/platform.py                |  134 +-
 src/borg/testsuite/remote.py                  |   44 +-
 src/borg/testsuite/repository.py              |  453 +-
 src/borg/testsuite/shellpattern.py            |  187 +-
 src/borg/testsuite/version.py                 |   76 +-
 src/borg/testsuite/xattr.py                   |   52 +-
 src/borg/upgrade.py                           |   73 +-
 src/borg/version.py                           |   14 +-
 src/borg/xattr.py                             |   32 +-
 78 files changed, 10568 insertions(+), 8337 deletions(-)

diff --git a/conftest.py b/conftest.py
index 6166b4759..1c08cbbda 100644
--- a/conftest.py
+++ b/conftest.py
@@ -3,8 +3,8 @@ import os
 import pytest
 
 # needed to get pretty assertion failures in unit tests:
-if hasattr(pytest, 'register_assert_rewrite'):
-    pytest.register_assert_rewrite('borg.testsuite')
+if hasattr(pytest, "register_assert_rewrite"):
+    pytest.register_assert_rewrite("borg.testsuite")
 
 
 import borg.cache  # noqa: E402
@@ -21,11 +21,10 @@ from borg.testsuite.platform import fakeroot_detected  # noqa: E402
 @pytest.fixture(autouse=True)
 def clean_env(tmpdir_factory, monkeypatch):
     # avoid that we access / modify the user's normal .config / .cache directory:
-    monkeypatch.setenv('XDG_CONFIG_HOME', str(tmpdir_factory.mktemp('xdg-config-home')))
-    monkeypatch.setenv('XDG_CACHE_HOME', str(tmpdir_factory.mktemp('xdg-cache-home')))
+    monkeypatch.setenv("XDG_CONFIG_HOME", str(tmpdir_factory.mktemp("xdg-config-home")))
+    monkeypatch.setenv("XDG_CACHE_HOME", str(tmpdir_factory.mktemp("xdg-cache-home")))
     # also avoid to use anything from the outside environment:
-    keys = [key for key in os.environ
-            if key.startswith('BORG_') and key not in ('BORG_FUSE_IMPL', )]
+    keys = [key for key in os.environ if key.startswith("BORG_") and key not in ("BORG_FUSE_IMPL",)]
     for key in keys:
         monkeypatch.delenv(key, raising=False)
     # Speed up tests
@@ -41,7 +40,7 @@ def pytest_report_header(config, startdir):
         "symlinks": are_symlinks_supported(),
         "hardlinks": are_hardlinks_supported(),
         "atime/mtime": is_utime_fully_supported(),
-        "modes": "BORG_TESTS_IGNORE_MODES" not in os.environ
+        "modes": "BORG_TESTS_IGNORE_MODES" not in os.environ,
     }
     enabled = []
     disabled = []
@@ -60,9 +59,11 @@ class DefaultPatches:
         self.org_cache_wipe_cache = borg.cache.LocalCache.wipe_cache
 
         def wipe_should_not_be_called(*a, **kw):
-            raise AssertionError("Cache wipe was triggered, if this is part of the test add "
-                                 "@pytest.mark.allow_cache_wipe")
-        if 'allow_cache_wipe' not in request.keywords:
+            raise AssertionError(
+                "Cache wipe was triggered, if this is part of the test add " "@pytest.mark.allow_cache_wipe"
+            )
+
+        if "allow_cache_wipe" not in request.keywords:
             borg.cache.LocalCache.wipe_cache = wipe_should_not_be_called
         request.addfinalizer(self.undo)
 
diff --git a/docs/conf.py b/docs/conf.py
index a4b1caf2f..fd13fed41 100644
--- a/docs/conf.py
+++ b/docs/conf.py
@@ -13,84 +13,85 @@
 # add these directories to sys.path here. If the directory is relative to the
 # documentation root, use os.path.abspath to make it absolute, like shown here.
 import sys, os
-sys.path.insert(0, os.path.abspath('../src'))
+
+sys.path.insert(0, os.path.abspath("../src"))
 
 from borg import __version__ as sw_version
 
 # -- General configuration -----------------------------------------------------
 
 # If your documentation needs a minimal Sphinx version, state it here.
-#needs_sphinx = '1.0'
+# needs_sphinx = '1.0'
 
 # Add any Sphinx extension module names here, as strings. They can be extensions
 # coming with Sphinx (named 'sphinx.ext.*') or your custom ones.
 extensions = []
 
 # Add any paths that contain templates here, relative to this directory.
-templates_path = ['_templates']
+templates_path = ["_templates"]
 
 # The suffix of source filenames.
-source_suffix = '.rst'
+source_suffix = ".rst"
 
 # The encoding of source files.
-#source_encoding = 'utf-8-sig'
+# source_encoding = 'utf-8-sig'
 
 # The master toctree document.
-master_doc = 'index'
+master_doc = "index"
 
 # General information about the project.
-project = 'Borg - Deduplicating Archiver'
-copyright = '2010-2014 Jonas Borgström, 2015-2022 The Borg Collective (see AUTHORS file)'
+project = "Borg - Deduplicating Archiver"
+copyright = "2010-2014 Jonas Borgström, 2015-2022 The Borg Collective (see AUTHORS file)"
 
 # The version info for the project you're documenting, acts as replacement for
 # |version| and |release|, also used in various other places throughout the
 # built documents.
 #
 # The short X.Y version.
-split_char = '+' if '+' in sw_version else '-'
+split_char = "+" if "+" in sw_version else "-"
 version = sw_version.split(split_char)[0]
 # The full version, including alpha/beta/rc tags.
 release = version
 
-suppress_warnings = ['image.nonlocal_uri']
+suppress_warnings = ["image.nonlocal_uri"]
 
 # The language for content autogenerated by Sphinx. Refer to documentation
 # for a list of supported languages.
-#language = None
+# language = None
 
 # There are two options for replacing |today|: either, you set today to some
 # non-false value, then it is used:
-#today = ''
+# today = ''
 # Else, today_fmt is used as the format for a strftime call.
-today_fmt = '%Y-%m-%d'
+today_fmt = "%Y-%m-%d"
 
 # List of patterns, relative to source directory, that match files and
 # directories to ignore when looking for source files.
-exclude_patterns = ['_build']
+exclude_patterns = ["_build"]
 
 # The reST default role (used for this markup: `text`) to use for all documents.
-#default_role = None
+# default_role = None
 
 # The Borg docs contain no or very little Python docs.
 # Thus, the primary domain is rst.
-primary_domain = 'rst'
+primary_domain = "rst"
 
 # If true, '()' will be appended to :func: etc. cross-reference text.
-#add_function_parentheses = True
+# add_function_parentheses = True
 
 # If true, the current module name will be prepended to all description
 # unit titles (such as .. function::).
-#add_module_names = True
+# add_module_names = True
 
 # If true, sectionauthor and moduleauthor directives will be shown in the
 # output. They are ignored by default.
-#show_authors = False
+# show_authors = False
 
 # The name of the Pygments (syntax highlighting) style to use.
-pygments_style = 'sphinx'
+pygments_style = "sphinx"
 
 # A list of ignored prefixes for module index sorting.
-#modindex_common_prefix = []
+# modindex_common_prefix = []
 
 
 # -- Options for HTML output ---------------------------------------------------
@@ -100,79 +101,73 @@ pygments_style = 'sphinx'
 import guzzle_sphinx_theme
 
 html_theme_path = guzzle_sphinx_theme.html_theme_path()
-html_theme = 'guzzle_sphinx_theme'
+html_theme = "guzzle_sphinx_theme"
 
 
 def set_rst_settings(app):
-    app.env.settings.update({
-        'field_name_limit': 0,
-        'option_limit': 0,
-    })
+    app.env.settings.update({"field_name_limit": 0, "option_limit": 0})
 
 
 def setup(app):
-    app.add_css_file('css/borg.css')
-    app.connect('builder-inited', set_rst_settings)
+    app.add_css_file("css/borg.css")
+    app.connect("builder-inited", set_rst_settings)
+
 
 # Theme options are theme-specific and customize the look and feel of a theme
 # further.  For a list of options available for each theme, see the
 # documentation.
-html_theme_options = {
-    'project_nav_name': 'Borg %s' % version,
-}
+html_theme_options = {"project_nav_name": "Borg %s" % version}
 
 # Add any paths that contain custom themes here, relative to this directory.
-#html_theme_path = ['_themes']
+# html_theme_path = ['_themes']
 
 # The name for this set of Sphinx documents.  If None, it defaults to
 # "<project> v<release> documentation".
-#html_title = None
+# html_title = None
 
 # A shorter title for the navigation bar.  Default is the same as html_title.
-#html_short_title = None
+# html_short_title = None
 
 # The name of an image file (relative to this directory) to place at the top
 # of the sidebar.
-html_logo = '_static/logo.svg'
+html_logo = "_static/logo.svg"
 
 # The name of an image file (within the static path) to use as favicon of the
 # docs.  This file should be a Windows icon file (.ico) being 16x16 or 32x32
 # pixels large.
-html_favicon = '_static/favicon.ico'
+html_favicon = "_static/favicon.ico"
 
 # Add any paths that contain custom static files (such as style sheets) here,
 # relative to this directory. They are copied after the builtin static files,
 # so a file named "default.css" will overwrite the builtin "default.css".
-html_static_path = ['borg_theme']
+html_static_path = ["borg_theme"]
 
-html_extra_path = ['../src/borg/paperkey.html']
+html_extra_path = ["../src/borg/paperkey.html"]
 
 # If not '', a 'Last updated on:' timestamp is inserted at every page bottom,
 # using the given strftime format.
-html_last_updated_fmt = '%Y-%m-%d'
+html_last_updated_fmt = "%Y-%m-%d"
 
 # If true, SmartyPants will be used to convert quotes and dashes to
 # typographically correct entities.
 html_use_smartypants = True
-smartquotes_action = 'qe'  # no D in there means "do not transform -- and ---"
+smartquotes_action = "qe"  # no D in there means "do not transform -- and ---"
 
 # Custom sidebar templates, maps document names to template names.
-html_sidebars = {
-    '**': ['logo-text.html', 'searchbox.html', 'globaltoc.html'],
-}
+html_sidebars = {"**": ["logo-text.html", "searchbox.html", "globaltoc.html"]}
 
 # Additional templates that should be rendered to pages, maps page names to
 # template names.
-#html_additional_pages = {}
+# html_additional_pages = {}
 
 # If false, no module index is generated.
-#html_domain_indices = True
+# html_domain_indices = True
 
 # If false, no index is generated.
 html_use_index = False
 
 # If true, the index is split into individual pages for each letter.
-#html_split_index = False
+# html_split_index = False
 
 # If true, links to the reST sources are added to the pages.
 html_show_sourcelink = False
@@ -186,57 +181,45 @@ html_show_copyright = False
 # If true, an OpenSearch description file will be output, and all pages will
 # contain a <link> tag referring to it.  The value of this option must be the
 # base URL from which the finished HTML is served.
-#html_use_opensearch = ''
+# html_use_opensearch = ''
 
 # This is the file name suffix for HTML files (e.g. ".xhtml").
-#html_file_suffix = None
+# html_file_suffix = None
 
 # Output file base name for HTML help builder.
-htmlhelp_basename = 'borgdoc'
+htmlhelp_basename = "borgdoc"
 
 
 # -- Options for LaTeX output --------------------------------------------------
 
 # Grouping the document tree into LaTeX files. List of tuples
 # (source start file, target name, title, author, documentclass [howto/manual]).
-latex_documents = [
-  ('book', 'Borg.tex', 'Borg Documentation',
-   'The Borg Collective', 'manual'),
-]
+latex_documents = [("book", "Borg.tex", "Borg Documentation", "The Borg Collective", "manual")]
 
 # The name of an image file (relative to this directory) to place at the top of
 # the title page.
-latex_logo = '_static/logo.pdf'
+latex_logo = "_static/logo.pdf"
 
-latex_elements = {
-    'papersize': 'a4paper',
-    'pointsize': '10pt',
-    'figure_align': 'H',
-}
+latex_elements = {"papersize": "a4paper", "pointsize": "10pt", "figure_align": "H"}
 
 # For "manual" documents, if this is true, then toplevel headings are parts,
 # not chapters.
-#latex_use_parts = False
+# latex_use_parts = False
 
 # If true, show page references after internal links.
-#latex_show_pagerefs = False
+# latex_show_pagerefs = False
 
 # If true, show URL addresses after external links.
-latex_show_urls = 'footnote'
+latex_show_urls = "footnote"
 
 # Additional stuff for the LaTeX preamble.
-#latex_preamble = ''
+# latex_preamble = ''
 
 # Documents to append as an appendix to all manuals.
-latex_appendices = [
-    'support',
-    'resources',
-    'changes',
-    'authors',
-]
+latex_appendices = ["support", "resources", "changes", "authors"]
 
 # If false, no module index is generated.
-#latex_domain_indices = True
+# latex_domain_indices = True
 
 
 # -- Options for manual page output --------------------------------------------
@@ -244,21 +227,24 @@ latex_appendices = [
 # One entry per manual page. List of tuples
 # (source start file, name, description, authors, manual section).
 man_pages = [
-        ('usage', 'borg',
-         'BorgBackup is a deduplicating backup program with optional compression and authenticated encryption.',
-         ['The Borg Collective (see AUTHORS file)'],
-         1),
+    (
+        "usage",
+        "borg",
+        "BorgBackup is a deduplicating backup program with optional compression and authenticated encryption.",
+        ["The Borg Collective (see AUTHORS file)"],
+        1,
+    )
 ]
 
 extensions = [
-    'sphinx.ext.extlinks',
-    'sphinx.ext.autodoc',
-    'sphinx.ext.todo',
-    'sphinx.ext.coverage',
-    'sphinx.ext.viewcode',
+    "sphinx.ext.extlinks",
+    "sphinx.ext.autodoc",
+    "sphinx.ext.todo",
+    "sphinx.ext.coverage",
+    "sphinx.ext.viewcode",
 ]
 
 extlinks = {
-    'issue': ('https://github.com/borgbackup/borg/issues/%s', '#'),
-    'targz_url': ('https://pypi.python.org/packages/source/b/borgbackup/%%s-%s.tar.gz' % version, None),
+    "issue": ("https://github.com/borgbackup/borg/issues/%s", "#"),
+    "targz_url": ("https://pypi.python.org/packages/source/b/borgbackup/%%s-%s.tar.gz" % version, None),
 }
diff --git a/scripts/errorlist.py b/scripts/errorlist.py
index c4a0e7a0e..6eae5056b 100755
--- a/scripts/errorlist.py
+++ b/scripts/errorlist.py
@@ -10,5 +10,5 @@ classes = Error.__subclasses__() + ErrorWithTraceback.__subclasses__()
 for cls in sorted(classes, key=lambda cls: (cls.__module__, cls.__qualname__)):
     if cls is ErrorWithTraceback:
         continue
-    print('   ', cls.__qualname__)
-    print(indent(cls.__doc__, ' ' * 8))
+    print("   ", cls.__qualname__)
+    print(indent(cls.__doc__, " " * 8))
diff --git a/scripts/glibc_check.py b/scripts/glibc_check.py
index 5f8344960..8c1585e6e 100755
--- a/scripts/glibc_check.py
+++ b/scripts/glibc_check.py
@@ -13,11 +13,11 @@ import sys
 
 verbose = True
 objdump = "objdump -T %s"
-glibc_re = re.compile(r'GLIBC_([0-9]\.[0-9]+)')
+glibc_re = re.compile(r"GLIBC_([0-9]\.[0-9]+)")
 
 
 def parse_version(v):
-    major, minor = v.split('.')
+    major, minor = v.split(".")
     return int(major), int(minor)
 
 
@@ -32,11 +32,9 @@ def main():
     overall_versions = set()
     for filename in filenames:
         try:
-            output = subprocess.check_output(objdump % filename, shell=True,
-                                             stderr=subprocess.STDOUT)
+            output = subprocess.check_output(objdump % filename, shell=True, stderr=subprocess.STDOUT)
             output = output.decode()
-            versions = {parse_version(match.group(1))
-                        for match in glibc_re.finditer(output)}
+            versions = {parse_version(match.group(1)) for match in glibc_re.finditer(output)}
             requires_glibc = max(versions)
             overall_versions.add(requires_glibc)
             if verbose:
@@ -50,14 +48,15 @@ def main():
 
     if verbose:
         if ok:
-            print("The binaries work with the given glibc %s." %
-                  format_version(given))
+            print("The binaries work with the given glibc %s." % format_version(given))
         else:
-            print("The binaries do not work with the given glibc %s. "
-                  "Minimum is: %s" % (format_version(given), format_version(wanted)))
+            print(
+                "The binaries do not work with the given glibc %s. "
+                "Minimum is: %s" % (format_version(given), format_version(wanted))
+            )
     return ok
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     ok = main()
     sys.exit(0 if ok else 1)
diff --git a/scripts/hash_sizes.py b/scripts/hash_sizes.py
index 68e6e160a..19a33916d 100644
--- a/scripts/hash_sizes.py
+++ b/scripts/hash_sizes.py
@@ -23,11 +23,11 @@ policies = [
     # which growth factor to use when growing a hashtable of size < upto
     # grow fast (*2.0) at the start so we do not have to resize too often (expensive).
     # grow slow (*1.1) for huge hash tables (do not jump too much in memory usage)
-    Policy(256*K, 2.0),
-    Policy(2*M, 1.7),
-    Policy(16*M, 1.4),
-    Policy(128*M, 1.2),
-    Policy(2*G-1, 1.1),
+    Policy(256 * K, 2.0),
+    Policy(2 * M, 1.7),
+    Policy(16 * M, 1.4),
+    Policy(128 * M, 1.2),
+    Policy(2 * G - 1, 1.1),
 ]
 
 
@@ -92,12 +92,15 @@ def main():
         sizes.append(p)
         i = int(i * grow_factor)
 
-    print("""\
+    print(
+        """\
 static int hash_sizes[] = {
     %s
 };
-""" % ', '.join(str(size) for size in sizes))
+"""
+        % ", ".join(str(size) for size in sizes)
+    )
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     main()
diff --git a/setup.py b/setup.py
index f2efad233..d79c8100a 100644
--- a/setup.py
+++ b/setup.py
@@ -22,11 +22,11 @@ except ImportError:
 sys.path += [os.path.dirname(__file__)]
 import setup_docs
 
-is_win32 = sys.platform.startswith('win32')
-is_openbsd = sys.platform.startswith('openbsd')
+is_win32 = sys.platform.startswith("win32")
+is_openbsd = sys.platform.startswith("openbsd")
 
 # Number of threads to use for cythonize, not used on windows
-cpu_threads = multiprocessing.cpu_count() if multiprocessing and multiprocessing.get_start_method() != 'spawn' else None
+cpu_threads = multiprocessing.cpu_count() if multiprocessing and multiprocessing.get_start_method() != "spawn" else None
 
 # How the build process finds the system libs:
 #
@@ -38,27 +38,23 @@ cpu_threads = multiprocessing.cpu_count() if multiprocessing and multiprocessing
 # 3. otherwise raise a fatal error.
 
 # Are we building on ReadTheDocs?
-on_rtd = os.environ.get('READTHEDOCS')
+on_rtd = os.environ.get("READTHEDOCS")
 
 # Extra cflags for all extensions, usually just warnings we want to explicitly enable
-cflags = [
-    '-Wall',
-    '-Wextra',
-    '-Wpointer-arith',
-]
+cflags = ["-Wall", "-Wextra", "-Wpointer-arith"]
 
-compress_source = 'src/borg/compress.pyx'
-crypto_ll_source = 'src/borg/crypto/low_level.pyx'
-chunker_source = 'src/borg/chunker.pyx'
-hashindex_source = 'src/borg/hashindex.pyx'
-item_source = 'src/borg/item.pyx'
-checksums_source = 'src/borg/checksums.pyx'
-platform_posix_source = 'src/borg/platform/posix.pyx'
-platform_linux_source = 'src/borg/platform/linux.pyx'
-platform_syncfilerange_source = 'src/borg/platform/syncfilerange.pyx'
-platform_darwin_source = 'src/borg/platform/darwin.pyx'
-platform_freebsd_source = 'src/borg/platform/freebsd.pyx'
-platform_windows_source = 'src/borg/platform/windows.pyx'
+compress_source = "src/borg/compress.pyx"
+crypto_ll_source = "src/borg/crypto/low_level.pyx"
+chunker_source = "src/borg/chunker.pyx"
+hashindex_source = "src/borg/hashindex.pyx"
+item_source = "src/borg/item.pyx"
+checksums_source = "src/borg/checksums.pyx"
+platform_posix_source = "src/borg/platform/posix.pyx"
+platform_linux_source = "src/borg/platform/linux.pyx"
+platform_syncfilerange_source = "src/borg/platform/syncfilerange.pyx"
+platform_darwin_source = "src/borg/platform/darwin.pyx"
+platform_freebsd_source = "src/borg/platform/freebsd.pyx"
+platform_windows_source = "src/borg/platform/windows.pyx"
 
 cython_sources = [
     compress_source,
@@ -67,7 +63,6 @@ cython_sources = [
     hashindex_source,
     item_source,
     checksums_source,
-
     platform_posix_source,
     platform_linux_source,
     platform_syncfilerange_source,
@@ -79,19 +74,20 @@ cython_sources = [
 if cythonize:
     Sdist = sdist
 else:
+
     class Sdist(sdist):
         def __init__(self, *args, **kwargs):
-            raise Exception('Cython is required to run sdist')
+            raise Exception("Cython is required to run sdist")
 
-    cython_c_files = [fn.replace('.pyx', '.c') for fn in cython_sources]
+    cython_c_files = [fn.replace(".pyx", ".c") for fn in cython_sources]
     if not on_rtd and not all(os.path.exists(path) for path in cython_c_files):
-        raise ImportError('The GIT version of Borg needs Cython. Install Cython or use a released version.')
+        raise ImportError("The GIT version of Borg needs Cython. Install Cython or use a released version.")
 
 
 def rm(file):
     try:
         os.unlink(file)
-        print('rm', file)
+        print("rm", file)
     except FileNotFoundError:
         pass
 
@@ -107,19 +103,19 @@ class Clean(Command):
 
     def run(self):
         for source in cython_sources:
-            genc = source.replace('.pyx', '.c')
+            genc = source.replace(".pyx", ".c")
             rm(genc)
-            compiled_glob = source.replace('.pyx', '.cpython*')
+            compiled_glob = source.replace(".pyx", ".cpython*")
             for compiled in sorted(glob(compiled_glob)):
                 rm(compiled)
 
 
 cmdclass = {
-    'build_ext': build_ext,
-    'build_usage': setup_docs.build_usage,
-    'build_man': setup_docs.build_man,
-    'sdist': Sdist,
-    'clean2': Clean,
+    "build_ext": build_ext,
+    "build_usage": setup_docs.build_usage,
+    "build_man": setup_docs.build_man,
+    "sdist": Sdist,
+    "clean2": Clean,
 }
 
 
@@ -137,16 +133,18 @@ if not on_rtd:
     try:
         import pkgconfig as pc
     except ImportError:
-        print('Warning: can not import pkgconfig python package.')
+        print("Warning: can not import pkgconfig python package.")
         pc = None
 
-    def lib_ext_kwargs(pc, prefix_env_var, lib_name, lib_pkg_name, pc_version, lib_subdir='lib'):
+    def lib_ext_kwargs(pc, prefix_env_var, lib_name, lib_pkg_name, pc_version, lib_subdir="lib"):
         system_prefix = os.environ.get(prefix_env_var)
         if system_prefix:
             print(f"Detected and preferring {lib_pkg_name} [via {prefix_env_var}]")
-            return dict(include_dirs=[os.path.join(system_prefix, 'include')],
-                        library_dirs=[os.path.join(system_prefix, lib_subdir)],
-                        libraries=[lib_name])
+            return dict(
+                include_dirs=[os.path.join(system_prefix, "include")],
+                library_dirs=[os.path.join(system_prefix, lib_subdir)],
+                libraries=[lib_name],
+            )
 
         if pc and pc.installed(lib_pkg_name, pc_version):
             print(f"Detected and preferring {lib_pkg_name} [via pkg-config]")
@@ -158,16 +156,13 @@ if not on_rtd:
 
     crypto_ldflags = []
     if is_win32:
-        crypto_ext_lib = lib_ext_kwargs(
-            pc, 'BORG_OPENSSL_PREFIX', 'libcrypto', 'libcrypto', '>=1.1.1', lib_subdir='')
+        crypto_ext_lib = lib_ext_kwargs(pc, "BORG_OPENSSL_PREFIX", "libcrypto", "libcrypto", ">=1.1.1", lib_subdir="")
     elif is_openbsd:
         # use openssl (not libressl) because we need AES-OCB and CHACHA20-POLY1305 via EVP api
-        crypto_ext_lib = lib_ext_kwargs(
-            pc, 'BORG_OPENSSL_PREFIX', 'crypto', 'libecrypto11', '>=1.1.1')
-        crypto_ldflags += ['-Wl,-rpath=/usr/local/lib/eopenssl11']
+        crypto_ext_lib = lib_ext_kwargs(pc, "BORG_OPENSSL_PREFIX", "crypto", "libecrypto11", ">=1.1.1")
+        crypto_ldflags += ["-Wl,-rpath=/usr/local/lib/eopenssl11"]
     else:
-        crypto_ext_lib = lib_ext_kwargs(
-            pc, 'BORG_OPENSSL_PREFIX', 'crypto', 'libcrypto', '>=1.1.1')
+        crypto_ext_lib = lib_ext_kwargs(pc, "BORG_OPENSSL_PREFIX", "crypto", "libcrypto", ">=1.1.1")
 
     crypto_ext_kwargs = members_appended(
         dict(sources=[crypto_ll_source]),
@@ -178,57 +173,60 @@ if not on_rtd:
 
     compress_ext_kwargs = members_appended(
         dict(sources=[compress_source]),
-        lib_ext_kwargs(pc, 'BORG_LIBLZ4_PREFIX', 'lz4', 'liblz4', '>= 1.7.0'),
-        lib_ext_kwargs(pc, 'BORG_LIBZSTD_PREFIX', 'zstd', 'libzstd', '>= 1.3.0'),
+        lib_ext_kwargs(pc, "BORG_LIBLZ4_PREFIX", "lz4", "liblz4", ">= 1.7.0"),
+        lib_ext_kwargs(pc, "BORG_LIBZSTD_PREFIX", "zstd", "libzstd", ">= 1.3.0"),
         dict(extra_compile_args=cflags),
     )
 
     checksums_ext_kwargs = members_appended(
         dict(sources=[checksums_source]),
-        lib_ext_kwargs(pc, 'BORG_LIBXXHASH_PREFIX', 'xxhash', 'libxxhash', '>= 0.7.3'),
+        lib_ext_kwargs(pc, "BORG_LIBXXHASH_PREFIX", "xxhash", "libxxhash", ">= 0.7.3"),
         dict(extra_compile_args=cflags),
     )
 
     ext_modules += [
-        Extension('borg.crypto.low_level', **crypto_ext_kwargs),
-        Extension('borg.compress', **compress_ext_kwargs),
-        Extension('borg.hashindex', [hashindex_source], extra_compile_args=cflags),
-        Extension('borg.item', [item_source], extra_compile_args=cflags),
-        Extension('borg.chunker', [chunker_source], extra_compile_args=cflags),
-        Extension('borg.checksums', **checksums_ext_kwargs),
+        Extension("borg.crypto.low_level", **crypto_ext_kwargs),
+        Extension("borg.compress", **compress_ext_kwargs),
+        Extension("borg.hashindex", [hashindex_source], extra_compile_args=cflags),
+        Extension("borg.item", [item_source], extra_compile_args=cflags),
+        Extension("borg.chunker", [chunker_source], extra_compile_args=cflags),
+        Extension("borg.checksums", **checksums_ext_kwargs),
     ]
 
-    posix_ext = Extension('borg.platform.posix', [platform_posix_source], extra_compile_args=cflags)
-    linux_ext = Extension('borg.platform.linux', [platform_linux_source], libraries=['acl'], extra_compile_args=cflags)
-    syncfilerange_ext = Extension('borg.platform.syncfilerange', [platform_syncfilerange_source], extra_compile_args=cflags)
-    freebsd_ext = Extension('borg.platform.freebsd', [platform_freebsd_source], extra_compile_args=cflags)
-    darwin_ext = Extension('borg.platform.darwin', [platform_darwin_source], extra_compile_args=cflags)
-    windows_ext = Extension('borg.platform.windows', [platform_windows_source], extra_compile_args=cflags)
+    posix_ext = Extension("borg.platform.posix", [platform_posix_source], extra_compile_args=cflags)
+    linux_ext = Extension("borg.platform.linux", [platform_linux_source], libraries=["acl"], extra_compile_args=cflags)
+    syncfilerange_ext = Extension(
+        "borg.platform.syncfilerange", [platform_syncfilerange_source], extra_compile_args=cflags
+    )
+    freebsd_ext = Extension("borg.platform.freebsd", [platform_freebsd_source], extra_compile_args=cflags)
+    darwin_ext = Extension("borg.platform.darwin", [platform_darwin_source], extra_compile_args=cflags)
+    windows_ext = Extension("borg.platform.windows", [platform_windows_source], extra_compile_args=cflags)
 
     if not is_win32:
         ext_modules.append(posix_ext)
     else:
         ext_modules.append(windows_ext)
-    if sys.platform == 'linux':
+    if sys.platform == "linux":
         ext_modules.append(linux_ext)
         ext_modules.append(syncfilerange_ext)
-    elif sys.platform.startswith('freebsd'):
+    elif sys.platform.startswith("freebsd"):
         ext_modules.append(freebsd_ext)
-    elif sys.platform == 'darwin':
+    elif sys.platform == "darwin":
         ext_modules.append(darwin_ext)
 
     # sometimes there's no need to cythonize
     # this breaks chained commands like 'clean sdist'
-    cythonizing = len(sys.argv) > 1 and sys.argv[1] not in (
-        ('clean', 'clean2', 'egg_info', '--help-commands', '--version')) and '--help' not in sys.argv[1:]
+    cythonizing = (
+        len(sys.argv) > 1
+        and sys.argv[1] not in (("clean", "clean2", "egg_info", "--help-commands", "--version"))
+        and "--help" not in sys.argv[1:]
+    )
 
     if cythonize and cythonizing:
-        cython_opts = dict(
-            compiler_directives={'language_level': '3str'},
-        )
+        cython_opts = dict(compiler_directives={"language_level": "3str"})
         if not is_win32:
             # compile .pyx extensions to .c in parallel, does not work on windows
-            cython_opts['nthreads'] = cpu_threads
+            cython_opts["nthreads"] = cpu_threads
 
         # generate C code from Cython for ALL supported platforms, so we have them in the sdist.
         # the sdist does not require Cython at install time, so we need all as C.
@@ -237,8 +235,4 @@ if not on_rtd:
         ext_modules = cythonize(ext_modules, **cython_opts)
 
 
-setup(
-    cmdclass=cmdclass,
-    ext_modules=ext_modules,
-    long_description=setup_docs.long_desc_from_readme()
-)
+setup(cmdclass=cmdclass, ext_modules=ext_modules, long_description=setup_docs.long_desc_from_readme())
diff --git a/setup_docs.py b/setup_docs.py
index 7d985ebff..c568a70a2 100644
--- a/setup_docs.py
+++ b/setup_docs.py
@@ -12,36 +12,34 @@ from setuptools import Command
 
 
 def long_desc_from_readme():
-    with open('README.rst') as fd:
+    with open("README.rst") as fd:
         long_description = fd.read()
         # remove header, but have one \n before first headline
-        start = long_description.find('What is BorgBackup?')
+        start = long_description.find("What is BorgBackup?")
         assert start >= 0
-        long_description = '\n' + long_description[start:]
+        long_description = "\n" + long_description[start:]
         # remove badges
-        long_description = re.compile(r'^\.\. start-badges.*^\.\. end-badges', re.M | re.S).sub('', long_description)
+        long_description = re.compile(r"^\.\. start-badges.*^\.\. end-badges", re.M | re.S).sub("", long_description)
         # remove unknown directives
-        long_description = re.compile(r'^\.\. highlight:: \w+$', re.M).sub('', long_description)
+        long_description = re.compile(r"^\.\. highlight:: \w+$", re.M).sub("", long_description)
         return long_description
 
 
 def format_metavar(option):
-    if option.nargs in ('*', '...'):
-        return '[%s...]' % option.metavar
-    elif option.nargs == '?':
-        return '[%s]' % option.metavar
+    if option.nargs in ("*", "..."):
+        return "[%s...]" % option.metavar
+    elif option.nargs == "?":
+        return "[%s]" % option.metavar
     elif option.nargs is None:
         return option.metavar
     else:
-        raise ValueError(f'Can\'t format metavar {option.metavar}, unknown nargs {option.nargs}!')
+        raise ValueError(f"Can't format metavar {option.metavar}, unknown nargs {option.nargs}!")
 
 
 class build_usage(Command):
     description = "generate usage for each command"
 
-    user_options = [
-        ('output=', 'O', 'output directory'),
-    ]
+    user_options = [("output=", "O", "output directory")]
 
     def initialize_options(self):
         pass
@@ -50,17 +48,19 @@ class build_usage(Command):
         pass
 
     def run(self):
-        print('generating usage docs')
+        print("generating usage docs")
         import borg
-        borg.doc_mode = 'build_man'
-        if not os.path.exists('docs/usage'):
-            os.mkdir('docs/usage')
+
+        borg.doc_mode = "build_man"
+        if not os.path.exists("docs/usage"):
+            os.mkdir("docs/usage")
         # allows us to build docs without the C modules fully loaded during help generation
         from borg.archiver import Archiver
-        parser = Archiver(prog='borg').build_parser()
+
+        parser = Archiver(prog="borg").build_parser()
         # borgfs has a separate man page to satisfy debian's "every program from a package
         # must have a man page" requirement, but it doesn't need a separate HTML docs page
-        #borgfs_parser = Archiver(prog='borgfs').build_parser()
+        # borgfs_parser = Archiver(prog='borgfs').build_parser()
 
         self.generate_level("", parser, Archiver)
 
@@ -68,7 +68,7 @@ class build_usage(Command):
         is_subcommand = False
         choices = {}
         for action in parser._actions:
-            if action.choices is not None and 'SubParsersAction' in str(action.__class__):
+            if action.choices is not None and "SubParsersAction" in str(action.__class__):
                 is_subcommand = True
                 for cmd, parser in action.choices.items():
                     choices[prefix + cmd] = parser
@@ -76,32 +76,37 @@ class build_usage(Command):
             choices.update(extra_choices)
         if prefix and not choices:
             return
-        print('found commands: %s' % list(choices.keys()))
+        print("found commands: %s" % list(choices.keys()))
 
         for command, parser in sorted(choices.items()):
-            if command.startswith('debug'):
-                print('skipping', command)
+            if command.startswith("debug"):
+                print("skipping", command)
                 continue
-            print('generating help for %s' % command)
+            print("generating help for %s" % command)
 
             if self.generate_level(command + " ", parser, Archiver):
                 continue
 
-            with open('docs/usage/%s.rst.inc' % command.replace(" ", "_"), 'w') as doc:
+            with open("docs/usage/%s.rst.inc" % command.replace(" ", "_"), "w") as doc:
                 doc.write(".. IMPORTANT: this file is auto-generated from borg's built-in help, do not edit!\n\n")
-                if command == 'help':
+                if command == "help":
                     for topic in Archiver.helptext:
-                        params = {"topic": topic,
-                                  "underline": '~' * len('borg help ' + topic)}
+                        params = {"topic": topic, "underline": "~" * len("borg help " + topic)}
                         doc.write(".. _borg_{topic}:\n\n".format(**params))
                         doc.write("borg help {topic}\n{underline}\n\n".format(**params))
                         doc.write(Archiver.helptext[topic])
                 else:
-                    params = {"command": command,
-                              "command_": command.replace(' ', '_'),
-                              "underline": '-' * len('borg ' + command)}
+                    params = {
+                        "command": command,
+                        "command_": command.replace(" ", "_"),
+                        "underline": "-" * len("borg " + command),
+                    }
                     doc.write(".. _borg_{command_}:\n\n".format(**params))
-                    doc.write("borg {command}\n{underline}\n.. code-block:: none\n\n    borg [common options] {command}".format(**params))
+                    doc.write(
+                        "borg {command}\n{underline}\n.. code-block:: none\n\n    borg [common options] {command}".format(
+                            **params
+                        )
+                    )
                     self.write_usage(parser, doc)
                     epilog = parser.epilog
                     parser.epilog = None
@@ -109,21 +114,21 @@ class build_usage(Command):
                     doc.write("\n\nDescription\n~~~~~~~~~~~\n")
                     doc.write(epilog)
 
-        if 'create' in choices:
-            common_options = [group for group in choices['create']._action_groups if group.title == 'Common options'][0]
-            with open('docs/usage/common-options.rst.inc', 'w') as doc:
+        if "create" in choices:
+            common_options = [group for group in choices["create"]._action_groups if group.title == "Common options"][0]
+            with open("docs/usage/common-options.rst.inc", "w") as doc:
                 self.write_options_group(common_options, doc, False, base_indent=0)
 
         return is_subcommand
 
     def write_usage(self, parser, fp):
         if any(len(o.option_strings) for o in parser._actions):
-            fp.write(' [options]')
+            fp.write(" [options]")
         for option in parser._actions:
             if option.option_strings:
                 continue
-            fp.write(' ' + format_metavar(option))
-        fp.write('\n\n')
+            fp.write(" " + format_metavar(option))
+        fp.write("\n\n")
 
     def write_options(self, parser, fp):
         def is_positional_group(group):
@@ -134,58 +139,58 @@ class build_usage(Command):
 
         def html_write(s):
             for line in s.splitlines():
-                fp.write('    ' + line + '\n')
+                fp.write("    " + line + "\n")
 
         rows = []
         for group in parser._action_groups:
-            if group.title == 'Common options':
+            if group.title == "Common options":
                 # (no of columns used, columns, ...)
-                rows.append((1, '.. class:: borg-common-opt-ref\n\n:ref:`common_options`'))
+                rows.append((1, ".. class:: borg-common-opt-ref\n\n:ref:`common_options`"))
             else:
                 if not group._group_actions:
                     continue
-                group_header = '**%s**' % group.title
+                group_header = "**%s**" % group.title
                 if group.description:
-                    group_header += ' — ' + group.description
+                    group_header += " — " + group.description
                 rows.append((1, group_header))
                 if is_positional_group(group):
                     for option in group._group_actions:
-                        rows.append((3, '', '``%s``' % option.metavar, option.help or ''))
+                        rows.append((3, "", "``%s``" % option.metavar, option.help or ""))
                 else:
                     for option in group._group_actions:
                         if option.metavar:
-                            option_fmt = '``%s ' + option.metavar + '``'
+                            option_fmt = "``%s " + option.metavar + "``"
                         else:
-                            option_fmt = '``%s``'
-                        option_str = ', '.join(option_fmt % s for s in option.option_strings)
-                        option_desc = textwrap.dedent((option.help or '') % option.__dict__)
-                        rows.append((3, '', option_str, option_desc))
+                            option_fmt = "``%s``"
+                        option_str = ", ".join(option_fmt % s for s in option.option_strings)
+                        option_desc = textwrap.dedent((option.help or "") % option.__dict__)
+                        rows.append((3, "", option_str, option_desc))
 
-        fp.write('.. only:: html\n\n')
+        fp.write(".. only:: html\n\n")
         table = io.StringIO()
-        table.write('.. class:: borg-options-table\n\n')
+        table.write(".. class:: borg-options-table\n\n")
         self.rows_to_table(rows, table.write)
-        fp.write(textwrap.indent(table.getvalue(), ' ' * 4))
+        fp.write(textwrap.indent(table.getvalue(), " " * 4))
 
         # LaTeX output:
         # Regular rST option lists (irregular column widths)
         latex_options = io.StringIO()
         for group in parser._action_groups:
-            if group.title == 'Common options':
-                latex_options.write('\n\n:ref:`common_options`\n')
-                latex_options.write('    |')
+            if group.title == "Common options":
+                latex_options.write("\n\n:ref:`common_options`\n")
+                latex_options.write("    |")
             else:
                 self.write_options_group(group, latex_options)
-        fp.write('\n.. only:: latex\n\n')
-        fp.write(textwrap.indent(latex_options.getvalue(), ' ' * 4))
+        fp.write("\n.. only:: latex\n\n")
+        fp.write(textwrap.indent(latex_options.getvalue(), " " * 4))
 
     def rows_to_table(self, rows, write):
         def write_row_separator():
-            write('+')
+            write("+")
             for column_width in column_widths:
-                write('-' * (column_width + 1))
-                write('+')
-            write('\n')
+                write("-" * (column_width + 1))
+                write("+")
+            write("\n")
 
         # Find column count and width
         column_count = max(columns for columns, *_ in rows)
@@ -201,22 +206,22 @@ class build_usage(Command):
             # where each cell contains no newline.
             rowspanning_cells = []
             original_cells = list(original_cells)
-            while any('\n' in cell for cell in original_cells):
+            while any("\n" in cell for cell in original_cells):
                 cell_bloc = []
                 for i, cell in enumerate(original_cells):
-                    pre, _, original_cells[i] = cell.partition('\n')
+                    pre, _, original_cells[i] = cell.partition("\n")
                     cell_bloc.append(pre)
                 rowspanning_cells.append(cell_bloc)
             rowspanning_cells.append(original_cells)
             for cells in rowspanning_cells:
                 for i, column_width in enumerate(column_widths):
                     if i < columns:
-                        write('| ')
+                        write("| ")
                         write(cells[i].ljust(column_width))
                     else:
-                        write('  ')
-                        write(''.ljust(column_width))
-                write('|\n')
+                        write("  ")
+                        write("".ljust(column_width))
+                write("|\n")
 
         write_row_separator()
         # This bit of JavaScript kills the <colgroup> that is invariably inserted by docutils,
@@ -224,7 +229,9 @@ class build_usage(Command):
         # with CSS alone.
         # Since this is HTML-only output, it would be possible to just generate a <table> directly,
         # but then we'd lose rST formatting.
-        write(textwrap.dedent("""
+        write(
+            textwrap.dedent(
+                """
         .. raw:: html
 
             <script type='text/javascript'>
@@ -232,88 +239,88 @@ class build_usage(Command):
                 $('.borg-options-table colgroup').remove();
             })
             </script>
-        """))
+        """
+            )
+        )
 
     def write_options_group(self, group, fp, with_title=True, base_indent=4):
         def is_positional_group(group):
             return any(not o.option_strings for o in group._group_actions)
 
-        indent = ' ' * base_indent
+        indent = " " * base_indent
 
         if is_positional_group(group):
             for option in group._group_actions:
-                fp.write(option.metavar + '\n')
-                fp.write(textwrap.indent(option.help or '', ' ' * base_indent) + '\n')
+                fp.write(option.metavar + "\n")
+                fp.write(textwrap.indent(option.help or "", " " * base_indent) + "\n")
             return
 
         if not group._group_actions:
             return
 
         if with_title:
-            fp.write('\n\n')
-            fp.write(group.title + '\n')
+            fp.write("\n\n")
+            fp.write(group.title + "\n")
 
         opts = OrderedDict()
 
         for option in group._group_actions:
             if option.metavar:
-                option_fmt = '%s ' + option.metavar
+                option_fmt = "%s " + option.metavar
             else:
-                option_fmt = '%s'
-            option_str = ', '.join(option_fmt % s for s in option.option_strings)
-            option_desc = textwrap.dedent((option.help or '') % option.__dict__)
-            opts[option_str] = textwrap.indent(option_desc, ' ' * 4)
+                option_fmt = "%s"
+            option_str = ", ".join(option_fmt % s for s in option.option_strings)
+            option_desc = textwrap.dedent((option.help or "") % option.__dict__)
+            opts[option_str] = textwrap.indent(option_desc, " " * 4)
 
         padding = len(max(opts)) + 1
 
         for option, desc in opts.items():
-            fp.write(indent + option.ljust(padding) + desc + '\n')
+            fp.write(indent + option.ljust(padding) + desc + "\n")
 
 
 class build_man(Command):
-    description = 'build man pages'
+    description = "build man pages"
 
     user_options = []
 
     see_also = {
-        'create': ('delete', 'prune', 'check', 'patterns', 'placeholders', 'compression'),
-        'recreate': ('patterns', 'placeholders', 'compression'),
-        'list': ('info', 'diff', 'prune', 'patterns'),
-        'info': ('list', 'diff'),
-        'rcreate': ('rdelete', 'rlist', 'check', 'key-import', 'key-export', 'key-change-passphrase'),
-        'key-import': ('key-export', ),
-        'key-export': ('key-import', ),
-        'mount': ('umount', 'extract'),  # Would be cooler if these two were on the same page
-        'umount': ('mount', ),
-        'extract': ('mount', ),
-        'delete': ('compact', ),
-        'prune': ('compact', ),
+        "create": ("delete", "prune", "check", "patterns", "placeholders", "compression"),
+        "recreate": ("patterns", "placeholders", "compression"),
+        "list": ("info", "diff", "prune", "patterns"),
+        "info": ("list", "diff"),
+        "rcreate": ("rdelete", "rlist", "check", "key-import", "key-export", "key-change-passphrase"),
+        "key-import": ("key-export",),
+        "key-export": ("key-import",),
+        "mount": ("umount", "extract"),  # Would be cooler if these two were on the same page
+        "umount": ("mount",),
+        "extract": ("mount",),
+        "delete": ("compact",),
+        "prune": ("compact",),
     }
 
-    rst_prelude = textwrap.dedent("""
+    rst_prelude = textwrap.dedent(
+        """
     .. role:: ref(title)
 
     .. |project_name| replace:: Borg
 
-    """)
+    """
+    )
 
     usage_group = {
-        'break-lock': 'lock',
-        'with-lock': 'lock',
-
-        'key_change-passphrase': 'key',
-        'key_change-location': 'key',
-        'key_export': 'key',
-        'key_import': 'key',
-        'key_migrate-to-repokey': 'key',
-
-        'export-tar': 'tar',
-        'import-tar': 'tar',
-
-        'benchmark_crud': 'benchmark',
-        'benchmark_cpu': 'benchmark',
-
-        'umount': 'mount',
+        "break-lock": "lock",
+        "with-lock": "lock",
+        "key_change-passphrase": "key",
+        "key_change-location": "key",
+        "key_export": "key",
+        "key_import": "key",
+        "key_migrate-to-repokey": "key",
+        "export-tar": "tar",
+        "import-tar": "tar",
+        "benchmark_crud": "benchmark",
+        "benchmark_cpu": "benchmark",
+        "umount": "mount",
     }
 
     def initialize_options(self):
@@ -323,16 +330,18 @@ class build_man(Command):
         pass
 
     def run(self):
-        print('building man pages (in docs/man)', file=sys.stderr)
+        print("building man pages (in docs/man)", file=sys.stderr)
         import borg
-        borg.doc_mode = 'build_man'
-        os.makedirs('docs/man', exist_ok=True)
+
+        borg.doc_mode = "build_man"
+        os.makedirs("docs/man", exist_ok=True)
         # allows us to build docs without the C modules fully loaded during help generation
         from borg.archiver import Archiver
-        parser = Archiver(prog='borg').build_parser()
-        borgfs_parser = Archiver(prog='borgfs').build_parser()
 
-        self.generate_level('', parser, Archiver, {'borgfs': borgfs_parser})
+        parser = Archiver(prog="borg").build_parser()
+        borgfs_parser = Archiver(prog="borgfs").build_parser()
+
+        self.generate_level("", parser, Archiver, {"borgfs": borgfs_parser})
         self.build_topic_pages(Archiver)
         self.build_intro_page()
 
@@ -340,7 +349,7 @@ class build_man(Command):
         is_subcommand = False
         choices = {}
         for action in parser._actions:
-            if action.choices is not None and 'SubParsersAction' in str(action.__class__):
+            if action.choices is not None and "SubParsersAction" in str(action.__class__):
                 is_subcommand = True
                 for cmd, parser in action.choices.items():
                     choices[prefix + cmd] = parser
@@ -350,50 +359,50 @@ class build_man(Command):
             return
 
         for command, parser in sorted(choices.items()):
-            if command.startswith('debug') or command == 'help':
+            if command.startswith("debug") or command == "help":
                 continue
 
             if command == "borgfs":
                 man_title = command
             else:
-                man_title = 'borg-' + command.replace(' ', '-')
-            print('building man page', man_title + '(1)', file=sys.stderr)
+                man_title = "borg-" + command.replace(" ", "-")
+            print("building man page", man_title + "(1)", file=sys.stderr)
 
-            is_intermediary = self.generate_level(command + ' ', parser, Archiver)
+            is_intermediary = self.generate_level(command + " ", parser, Archiver)
 
             doc, write = self.new_doc()
             self.write_man_header(write, man_title, parser.description)
 
-            self.write_heading(write, 'SYNOPSIS')
+            self.write_heading(write, "SYNOPSIS")
             if is_intermediary:
-                subparsers = [action for action in parser._actions if 'SubParsersAction' in str(action.__class__)][0]
+                subparsers = [action for action in parser._actions if "SubParsersAction" in str(action.__class__)][0]
                 for subcommand in subparsers.choices:
-                    write('| borg', '[common options]', command, subcommand, '...')
-                    self.see_also.setdefault(command, []).append(f'{command}-{subcommand}')
+                    write("| borg", "[common options]", command, subcommand, "...")
+                    self.see_also.setdefault(command, []).append(f"{command}-{subcommand}")
             else:
                 if command == "borgfs":
-                    write(command, end='')
+                    write(command, end="")
                 else:
-                    write('borg', '[common options]', command, end='')
+                    write("borg", "[common options]", command, end="")
                 self.write_usage(write, parser)
-            write('\n')
+            write("\n")
 
-            description, _, notes = parser.epilog.partition('\n.. man NOTES')
+            description, _, notes = parser.epilog.partition("\n.. man NOTES")
 
             if description:
-                self.write_heading(write, 'DESCRIPTION')
+                self.write_heading(write, "DESCRIPTION")
                 write(description)
 
             if not is_intermediary:
-                self.write_heading(write, 'OPTIONS')
-                write('See `borg-common(1)` for common options of Borg commands.')
+                self.write_heading(write, "OPTIONS")
+                write("See `borg-common(1)` for common options of Borg commands.")
                 write()
                 self.write_options(write, parser)
 
                 self.write_examples(write, command)
 
             if notes:
-                self.write_heading(write, 'NOTES')
+                self.write_heading(write, "NOTES")
                 write(notes)
 
             self.write_see_also(write, man_title)
@@ -401,14 +410,14 @@ class build_man(Command):
             self.gen_man_page(man_title, doc.getvalue())
 
         # Generate the borg-common(1) man page with the common options.
-        if 'create' in choices:
+        if "create" in choices:
             doc, write = self.new_doc()
-            man_title = 'borg-common'
-            self.write_man_header(write, man_title, 'Common options of Borg commands')
+            man_title = "borg-common"
+            self.write_man_header(write, man_title, "Common options of Borg commands")
 
-            common_options = [group for group in choices['create']._action_groups if group.title == 'Common options'][0]
+            common_options = [group for group in choices["create"]._action_groups if group.title == "Common options"][0]
 
-            self.write_heading(write, 'SYNOPSIS')
+            self.write_heading(write, "SYNOPSIS")
             self.write_options_group(write, common_options)
             self.write_see_also(write, man_title)
             self.gen_man_page(man_title, doc.getvalue())
@@ -418,20 +427,20 @@ class build_man(Command):
     def build_topic_pages(self, Archiver):
         for topic, text in Archiver.helptext.items():
             doc, write = self.new_doc()
-            man_title = 'borg-' + topic
-            print('building man page', man_title + '(1)', file=sys.stderr)
+            man_title = "borg-" + topic
+            print("building man page", man_title + "(1)", file=sys.stderr)
 
-            self.write_man_header(write, man_title, 'Details regarding ' + topic)
-            self.write_heading(write, 'DESCRIPTION')
+            self.write_man_header(write, man_title, "Details regarding " + topic)
+            self.write_heading(write, "DESCRIPTION")
             write(text)
             self.gen_man_page(man_title, doc.getvalue())
 
     def build_intro_page(self):
         doc, write = self.new_doc()
-        man_title = 'borg'
-        print('building man page borg(1)', file=sys.stderr)
+        man_title = "borg"
+        print("building man page borg(1)", file=sys.stderr)
 
-        with open('docs/man_intro.rst') as fd:
+        with open("docs/man_intro.rst") as fd:
             man_intro = fd.read()
 
         self.write_man_header(write, man_title, "deduplicating and encrypting backup tool")
@@ -446,9 +455,10 @@ class build_man(Command):
     def printer(self, fd):
         def write(*args, **kwargs):
             print(*args, file=fd, **kwargs)
+
         return write
 
-    def write_heading(self, write, header, char='-', double_sided=False):
+    def write_heading(self, write, header, char="-", double_sided=False):
         write()
         if double_sided:
             write(char * len(header))
@@ -457,43 +467,43 @@ class build_man(Command):
         write()
 
     def write_man_header(self, write, title, description):
-        self.write_heading(write, title, '=', double_sided=True)
+        self.write_heading(write, title, "=", double_sided=True)
         self.write_heading(write, description, double_sided=True)
         # man page metadata
-        write(':Author: The Borg Collective')
-        write(':Date:', datetime.utcnow().date().isoformat())
-        write(':Manual section: 1')
-        write(':Manual group: borg backup tool')
+        write(":Author: The Borg Collective")
+        write(":Date:", datetime.utcnow().date().isoformat())
+        write(":Manual section: 1")
+        write(":Manual group: borg backup tool")
         write()
 
     def write_examples(self, write, command):
-        command = command.replace(' ', '_')
-        with open('docs/usage/%s.rst' % self.usage_group.get(command, command)) as fd:
+        command = command.replace(" ", "_")
+        with open("docs/usage/%s.rst" % self.usage_group.get(command, command)) as fd:
             usage = fd.read()
-            usage_include = '.. include:: %s.rst.inc' % command
+            usage_include = ".. include:: %s.rst.inc" % command
             begin = usage.find(usage_include)
-            end = usage.find('.. include', begin + 1)
+            end = usage.find(".. include", begin + 1)
             # If a command has a dedicated anchor, it will occur before the command's include.
-            if 0 < usage.find('.. _', begin + 1) < end:
-                end = usage.find('.. _', begin + 1)
+            if 0 < usage.find(".. _", begin + 1) < end:
+                end = usage.find(".. _", begin + 1)
             examples = usage[begin:end]
-            examples = examples.replace(usage_include, '')
-            examples = examples.replace('Examples\n~~~~~~~~', '')
-            examples = examples.replace('Miscellaneous Help\n------------------', '')
-            examples = examples.replace('``docs/misc/prune-example.txt``:', '``docs/misc/prune-example.txt``.')
-            examples = examples.replace('.. highlight:: none\n', '')  # we don't support highlight
-            examples = re.sub('^(~+)$', lambda matches: '+' * len(matches.group(0)), examples, flags=re.MULTILINE)
+            examples = examples.replace(usage_include, "")
+            examples = examples.replace("Examples\n~~~~~~~~", "")
+            examples = examples.replace("Miscellaneous Help\n------------------", "")
+            examples = examples.replace("``docs/misc/prune-example.txt``:", "``docs/misc/prune-example.txt``.")
+            examples = examples.replace(".. highlight:: none\n", "")  # we don't support highlight
+            examples = re.sub("^(~+)$", lambda matches: "+" * len(matches.group(0)), examples, flags=re.MULTILINE)
             examples = examples.strip()
         if examples:
-            self.write_heading(write, 'EXAMPLES', '-')
+            self.write_heading(write, "EXAMPLES", "-")
             write(examples)
 
     def write_see_also(self, write, man_title):
-        see_also = self.see_also.get(man_title.replace('borg-', ''), ())
-        see_also = ['`borg-%s(1)`' % s for s in see_also]
-        see_also.insert(0, '`borg-common(1)`')
-        self.write_heading(write, 'SEE ALSO')
-        write(', '.join(see_also))
+        see_also = self.see_also.get(man_title.replace("borg-", ""), ())
+        see_also = ["`borg-%s(1)`" % s for s in see_also]
+        see_also.insert(0, "`borg-common(1)`")
+        self.write_heading(write, "SEE ALSO")
+        write(", ".join(see_also))
 
     def gen_man_page(self, name, rst):
         from docutils.writers import manpage
@@ -502,29 +512,29 @@ class build_man(Command):
         from docutils.parsers.rst import roles
 
         def issue(name, rawtext, text, lineno, inliner, options={}, content=[]):
-            return [inline(rawtext, '#' + text)], []
+            return [inline(rawtext, "#" + text)], []
 
-        roles.register_local_role('issue', issue)
+        roles.register_local_role("issue", issue)
         # We give the source_path so that docutils can find relative includes
         # as-if the document where located in the docs/ directory.
-        man_page = publish_string(source=rst, source_path='docs/%s.rst' % name, writer=manpage.Writer())
-        with open('docs/man/%s.1' % name, 'wb') as fd:
+        man_page = publish_string(source=rst, source_path="docs/%s.rst" % name, writer=manpage.Writer())
+        with open("docs/man/%s.1" % name, "wb") as fd:
             fd.write(man_page)
 
     def write_usage(self, write, parser):
         if any(len(o.option_strings) for o in parser._actions):
-            write(' [options] ', end='')
+            write(" [options] ", end="")
         for option in parser._actions:
             if option.option_strings:
                 continue
-            write(format_metavar(option), end=' ')
+            write(format_metavar(option), end=" ")
 
     def write_options(self, write, parser):
         for group in parser._action_groups:
-            if group.title == 'Common options' or not group._group_actions:
+            if group.title == "Common options" or not group._group_actions:
                 continue
-            title = 'arguments' if group.title == 'positional arguments' else group.title
-            self.write_heading(write, title, '+')
+            title = "arguments" if group.title == "positional arguments" else group.title
+            self.write_heading(write, title, "+")
             self.write_options_group(write, group)
 
     def write_options_group(self, write, group):
@@ -534,19 +544,19 @@ class build_man(Command):
         if is_positional_group(group):
             for option in group._group_actions:
                 write(option.metavar)
-                write(textwrap.indent(option.help or '', ' ' * 4))
+                write(textwrap.indent(option.help or "", " " * 4))
             return
 
         opts = OrderedDict()
 
         for option in group._group_actions:
             if option.metavar:
-                option_fmt = '%s ' + option.metavar
+                option_fmt = "%s " + option.metavar
             else:
-                option_fmt = '%s'
-            option_str = ', '.join(option_fmt % s for s in option.option_strings)
-            option_desc = textwrap.dedent((option.help or '') % option.__dict__)
-            opts[option_str] = textwrap.indent(option_desc, ' ' * 4)
+                option_fmt = "%s"
+            option_str = ", ".join(option_fmt % s for s in option.option_strings)
+            option_desc = textwrap.dedent((option.help or "") % option.__dict__)
+            opts[option_str] = textwrap.indent(option_desc, " " * 4)
 
         padding = len(max(opts)) + 1
 
diff --git a/src/borg/__init__.py b/src/borg/__init__.py
index b2597288e..d05eff6e0 100644
--- a/src/borg/__init__.py
+++ b/src/borg/__init__.py
@@ -9,11 +9,13 @@ __version_tuple__ = _v._version.release
 # assert that all semver components are integers
 # this is mainly to show errors when people repackage poorly
 # and setuptools_scm determines a 0.1.dev... version
-assert all(isinstance(v, int) for v in __version_tuple__), \
+assert all(isinstance(v, int) for v in __version_tuple__), (
     """\
 broken borgbackup version metadata: %r
 
 version metadata is obtained dynamically on installation via setuptools_scm,
 please ensure your git repo has the correct tags or you provide the version
 using SETUPTOOLS_SCM_PRETEND_VERSION in your build script.
-""" % __version__
+"""
+    % __version__
+)
diff --git a/src/borg/__main__.py b/src/borg/__main__.py
index 73a2187de..a1dbbdc34 100644
--- a/src/borg/__main__.py
+++ b/src/borg/__main__.py
@@ -5,11 +5,12 @@ import os
 # containing the dll is not in the search path. The dll is shipped
 # with python in the "DLLs" folder, so let's add this folder
 # to the path. The folder is always in sys.path, get it from there.
-if sys.platform.startswith('win32'):
+if sys.platform.startswith("win32"):
     # Keep it an iterable to support multiple folder which contain "DLLs".
-    dll_path = (p for p in sys.path if 'DLLs' in os.path.normpath(p).split(os.path.sep))
-    os.environ['PATH'] = os.pathsep.join(dll_path) + os.pathsep + os.environ['PATH']
+    dll_path = (p for p in sys.path if "DLLs" in os.path.normpath(p).split(os.path.sep))
+    os.environ["PATH"] = os.pathsep.join(dll_path) + os.pathsep + os.environ["PATH"]
 
 
 from borg.archiver import main
+
 main()
diff --git a/src/borg/archive.py b/src/borg/archive.py
index 172f43cae..d346a425f 100644
--- a/src/borg/archive.py
+++ b/src/borg/archive.py
@@ -49,11 +49,10 @@ from .platform import acl_get, acl_set, set_flags, get_flags, swidth, hostname
 from .remote import cache_if_remote
 from .repository import Repository, LIST_SCAN_LIMIT
 
-has_link = hasattr(os, 'link')
+has_link = hasattr(os, "link")
 
 
 class Statistics:
-
     def __init__(self, output_json=False, iec=False):
         self.output_json = output_json
         self.iec = iec
@@ -73,7 +72,7 @@ class Statistics:
 
     def __add__(self, other):
         if not isinstance(other, Statistics):
-            raise TypeError('can only add Statistics objects')
+            raise TypeError("can only add Statistics objects")
         stats = Statistics(self.output_json, self.iec)
         stats.osize = self.osize + other.osize
         stats.usize = self.usize + other.usize
@@ -88,34 +87,37 @@ class Statistics:
 Number of files: {stats.nfiles}
 Original size: {stats.osize_fmt}
 Deduplicated size: {stats.usize_fmt}
-""".format(stats=self)
+""".format(
+            stats=self
+        )
 
     def __repr__(self):
         return "<{cls} object at {hash:#x} ({self.osize}, {self.usize})>".format(
-            cls=type(self).__name__, hash=id(self), self=self)
+            cls=type(self).__name__, hash=id(self), self=self
+        )
 
     def as_dict(self):
         return {
-            'original_size': FileSize(self.osize, iec=self.iec),
-            'deduplicated_size': FileSize(self.usize, iec=self.iec),
-            'nfiles': self.nfiles,
+            "original_size": FileSize(self.osize, iec=self.iec),
+            "deduplicated_size": FileSize(self.usize, iec=self.iec),
+            "nfiles": self.nfiles,
         }
 
     def as_raw_dict(self):
         return {
-            'size': self.osize,
-            'nfiles': self.nfiles,
-            'size_parts': self.osize_parts,
-            'nfiles_parts': self.nfiles_parts,
+            "size": self.osize,
+            "nfiles": self.nfiles,
+            "size_parts": self.osize_parts,
+            "nfiles_parts": self.nfiles_parts,
         }
 
     @classmethod
     def from_raw_dict(cls, **kw):
         self = cls()
-        self.osize = kw['size']
-        self.nfiles = kw['nfiles']
-        self.osize_parts = kw['size_parts']
-        self.nfiles_parts = kw['nfiles_parts']
+        self.osize = kw["size"]
+        self.nfiles = kw["nfiles"]
+        self.osize_parts = kw["size_parts"]
+        self.nfiles_parts = kw["nfiles_parts"]
         return self
 
     @property
@@ -133,30 +135,26 @@ Deduplicated size: {stats.usize_fmt}
             if self.output_json:
                 if not final:
                     data = self.as_dict()
-                    data['path'] = remove_surrogates(item.path if item else '')
+                    data["path"] = remove_surrogates(item.path if item else "")
                 else:
                     data = {}
-                data.update({
-                    'time': time.time(),
-                    'type': 'archive_progress',
-                    'finished': final,
-                })
+                data.update({"time": time.time(), "type": "archive_progress", "finished": final})
                 msg = json.dumps(data)
-                end = '\n'
+                end = "\n"
             else:
                 columns, lines = get_terminal_size()
                 if not final:
-                    msg = '{0.osize_fmt} O {0.usize_fmt} U {0.nfiles} N '.format(self)
-                    path = remove_surrogates(item.path) if item else ''
+                    msg = "{0.osize_fmt} O {0.usize_fmt} U {0.nfiles} N ".format(self)
+                    path = remove_surrogates(item.path) if item else ""
                     space = columns - swidth(msg)
                     if space < 12:
-                        msg = ''
+                        msg = ""
                         space = columns - swidth(msg)
                     if space >= 8:
                         msg += ellipsis_truncate(path, space)
                 else:
-                    msg = ' ' * columns
-                end = '\r'
+                    msg = " " * columns
+                end = "\r"
             print(msg, end=end, file=stream or sys.stderr, flush=True)
 
 
@@ -181,6 +179,7 @@ class BackupOSError(Exception):
 
     Any unwrapped IO error is critical and aborts execution (for example repository IO failure).
     """
+
     def __init__(self, op, os_error):
         self.op = op
         self.os_error = os_error
@@ -190,15 +189,15 @@ class BackupOSError(Exception):
 
     def __str__(self):
         if self.op:
-            return f'{self.op}: {self.os_error}'
+            return f"{self.op}: {self.os_error}"
         else:
             return str(self.os_error)
 
 
 class BackupIO:
-    op = ''
+    op = ""
 
-    def __call__(self, op=''):
+    def __call__(self, op=""):
         self.op = op
         return self
 
@@ -214,7 +213,7 @@ backup_io = BackupIO()
 
 
 def backup_io_iter(iterator):
-    backup_io.op = 'read'
+    backup_io.op = "read"
     while True:
         with backup_io:
             try:
@@ -242,16 +241,16 @@ def stat_update_check(st_old, st_curr):
     # are not duplicate in a short timeframe, this check is redundant and solved by the ino check:
     if stat.S_IFMT(st_old.st_mode) != stat.S_IFMT(st_curr.st_mode):
         # in this case, we dispatched to wrong handler - abort
-        raise BackupError('file type changed (race condition), skipping file')
+        raise BackupError("file type changed (race condition), skipping file")
     if st_old.st_ino != st_curr.st_ino:
         # in this case, the hardlinks-related code in create_helper has the wrong inode - abort!
-        raise BackupError('file inode changed (race condition), skipping file')
+        raise BackupError("file inode changed (race condition), skipping file")
     # looks ok, we are still dealing with the same thing - return current stat:
     return st_curr
 
 
 @contextmanager
-def OsOpen(*, flags, path=None, parent_fd=None, name=None, noatime=False, op='open'):
+def OsOpen(*, flags, path=None, parent_fd=None, name=None, noatime=False, op="open"):
     with backup_io(op):
         fd = os_open(path=path, parent_fd=parent_fd, name=name, flags=flags, noatime=noatime)
     try:
@@ -263,7 +262,6 @@ def OsOpen(*, flags, path=None, parent_fd=None, name=None, noatime=False, op='op
 
 
 class DownloadPipeline:
-
     def __init__(self, repository, key):
         self.repository = repository
         self.key = key
@@ -284,7 +282,7 @@ class DownloadPipeline:
             unpacker.feed(data)
             items = [Item(internal_dict=item) for item in unpacker]
             for item in items:
-                if 'chunks' in item:
+                if "chunks" in item:
                     item.chunks = [ChunkListEntry(*e) for e in item.chunks]
 
             if filter:
@@ -292,8 +290,8 @@ class DownloadPipeline:
 
             if preload:
                 for item in items:
-                    if 'chunks' in item:
-                        hlid = item.get('hlid', None)
+                    if "chunks" in item:
+                        hlid = item.get("hlid", None)
                         if hlid is None:
                             preload_chunks = True
                         else:
@@ -342,11 +340,11 @@ class ChunkBuffer:
         # with CH_ALLOC (and CH_HOLE, for completeness) here.
         chunks = []
         for chunk in self.chunker.chunkify(self.buffer):
-            alloc = chunk.meta['allocation']
+            alloc = chunk.meta["allocation"]
             if alloc == CH_DATA:
                 data = bytes(chunk.data)
             elif alloc in (CH_ALLOC, CH_HOLE):
-                data = zeros[:chunk.meta['size']]
+                data = zeros[: chunk.meta["size"]]
             else:
                 raise ValueError("chunk allocation has unsupported value of %r" % alloc)
             chunks.append(data)
@@ -364,7 +362,6 @@ class ChunkBuffer:
 
 
 class CacheChunkBuffer(ChunkBuffer):
-
     def __init__(self, cache, key, stats, chunker_params=ITEMS_CHUNKER_PARAMS):
         super().__init__(key, chunker_params)
         self.cache = cache
@@ -380,14 +377,14 @@ def get_item_uid_gid(item, *, numeric, uid_forced=None, gid_forced=None, uid_def
     if uid_forced is not None:
         uid = uid_forced
     else:
-        uid = None if numeric else user2uid(item.get('user'))
+        uid = None if numeric else user2uid(item.get("user"))
         uid = item.uid if uid is None else uid
         if uid < 0:
             uid = uid_default
     if gid_forced is not None:
         gid = gid_forced
     else:
-        gid = None if numeric else group2gid(item.get('group'))
+        gid = None if numeric else group2gid(item.get("group"))
         gid = item.gid if gid is None else gid
         if gid < 0:
             gid = gid_default
@@ -395,7 +392,6 @@ def get_item_uid_gid(item, *, numeric, uid_forced=None, gid_forced=None, uid_def
 
 
 class Archive:
-
     class DoesNotExist(Error):
         """Archive {} does not exist"""
 
@@ -405,11 +401,30 @@ class Archive:
     class IncompatibleFilesystemEncodingError(Error):
         """Failed to encode filename "{}" into file system encoding "{}". Consider configuring the LANG environment variable."""
 
-    def __init__(self, repository, key, manifest, name, cache=None, create=False,
-                 checkpoint_interval=1800, numeric_ids=False, noatime=False, noctime=False,
-                 noflags=False, noacls=False, noxattrs=False,
-                 progress=False, chunker_params=CHUNKER_PARAMS, start=None, start_monotonic=None, end=None,
-                 consider_part_files=False, log_json=False, iec=False):
+    def __init__(
+        self,
+        repository,
+        key,
+        manifest,
+        name,
+        cache=None,
+        create=False,
+        checkpoint_interval=1800,
+        numeric_ids=False,
+        noatime=False,
+        noctime=False,
+        noflags=False,
+        noacls=False,
+        noxattrs=False,
+        progress=False,
+        chunker_params=CHUNKER_PARAMS,
+        start=None,
+        start_monotonic=None,
+        end=None,
+        consider_part_files=False,
+        log_json=False,
+        iec=False,
+    ):
         self.cwd = os.getcwd()
         self.key = key
         self.repository = repository
@@ -428,7 +443,9 @@ class Archive:
         self.noflags = noflags
         self.noacls = noacls
         self.noxattrs = noxattrs
-        assert (start is None) == (start_monotonic is None), 'Logic error: if start is given, start_monotonic must be given as well and vice versa.'
+        assert (start is None) == (
+            start_monotonic is None
+        ), "Logic error: if start is given, start_monotonic must be given as well and vice versa."
         if start is None:
             start = datetime.utcnow()
             start_monotonic = time.monotonic()
@@ -447,7 +464,7 @@ class Archive:
                 raise self.AlreadyExists(name)
             i = 0
             while True:
-                self.checkpoint_name = '{}.checkpoint{}'.format(name, i and ('.%d' % i) or '')
+                self.checkpoint_name = "{}.checkpoint{}".format(name, i and (".%d" % i) or "")
                 if self.checkpoint_name not in manifest.archives:
                     break
                 i += 1
@@ -461,14 +478,14 @@ class Archive:
         data = self.key.decrypt(id, self.repository.get(id))
         metadata = ArchiveItem(internal_dict=msgpack.unpackb(data))
         if metadata.version not in (1, 2):  # legacy: still need to read v1 archives
-            raise Exception('Unknown archive metadata version')
+            raise Exception("Unknown archive metadata version")
         return metadata
 
     def load(self, id):
         self.id = id
         self.metadata = self._load_meta(self.id)
         self.name = self.metadata.name
-        self.comment = self.metadata.get('comment', '')
+        self.comment = self.metadata.get("comment", "")
 
     @property
     def ts(self):
@@ -480,7 +497,7 @@ class Archive:
     def ts_end(self):
         """Timestamp of archive creation (end) in UTC"""
         # fall back to time if there is no time_end present in metadata
-        ts = self.metadata.get('time_end') or self.metadata.time
+        ts = self.metadata.get("time_end") or self.metadata.time
         return parse_timestamp(ts)
 
     @property
@@ -509,30 +526,30 @@ class Archive:
             start = self.ts
             end = self.ts_end
         info = {
-            'name': self.name,
-            'id': self.fpr,
-            'start': OutputTimestamp(start),
-            'end': OutputTimestamp(end),
-            'duration': (end - start).total_seconds(),
-            'stats': stats.as_dict(),
-            'limits': {
-                'max_archive_size': self._archive_csize() / MAX_DATA_SIZE,
-            },
+            "name": self.name,
+            "id": self.fpr,
+            "start": OutputTimestamp(start),
+            "end": OutputTimestamp(end),
+            "duration": (end - start).total_seconds(),
+            "stats": stats.as_dict(),
+            "limits": {"max_archive_size": self._archive_csize() / MAX_DATA_SIZE},
         }
         if self.create:
-            info['command_line'] = sys.argv
+            info["command_line"] = sys.argv
         else:
-            info.update({
-                'command_line': self.metadata.cmdline,
-                'hostname': self.metadata.hostname,
-                'username': self.metadata.username,
-                'comment': self.metadata.get('comment', ''),
-                'chunker_params': self.metadata.get('chunker_params', ''),
-            })
+            info.update(
+                {
+                    "command_line": self.metadata.cmdline,
+                    "hostname": self.metadata.hostname,
+                    "username": self.metadata.username,
+                    "comment": self.metadata.get("comment", ""),
+                    "chunker_params": self.metadata.get("chunker_params", ""),
+                }
+            )
         return info
 
     def __str__(self):
-        return '''\
+        return """\
 Repository: {location}
 Archive name: {0.name}
 Archive fingerprint: {0.fpr}
@@ -540,19 +557,19 @@ Time (start): {start}
 Time (end):   {end}
 Duration: {0.duration}
 Utilization of max. archive size: {csize_max:.0%}
-'''.format(
+""".format(
             self,
             start=OutputTimestamp(self.start.replace(tzinfo=timezone.utc)),
             end=OutputTimestamp(self.end.replace(tzinfo=timezone.utc)),
             csize_max=self._archive_csize() / MAX_DATA_SIZE,
-            location=self.repository._location.canonical_path()
-)
+            location=self.repository._location.canonical_path(),
+        )
 
     def __repr__(self):
-        return 'Archive(%r)' % self.name
+        return "Archive(%r)" % self.name
 
     def item_filter(self, item, filter=None):
-        if not self.consider_part_files and 'part' in item:
+        if not self.consider_part_files and "part" in item:
             # this is a part(ial) file, we usually don't want to consider it.
             return False
         return filter(item) if filter else True
@@ -560,8 +577,9 @@ Utilization of max. archive size: {csize_max:.0%}
     def iter_items(self, filter=None, preload=False):
         # note: when calling this with preload=True, later fetch_many() must be called with
         # is_preloaded=True or the RemoteRepository code will leak memory!
-        for item in self.pipeline.unpack_many(self.metadata.items, preload=preload,
-                                              filter=lambda item: self.item_filter(item, filter)):
+        for item in self.pipeline.unpack_many(
+            self.metadata.items, preload=preload, filter=lambda item: self.item_filter(item, filter)
+        ):
             yield item
 
     def add_item(self, item, show_progress=True, stats=None):
@@ -591,34 +609,37 @@ Utilization of max. archive size: {csize_max:.0%}
         self.start = start
         self.end = end
         metadata = {
-            'version': 2,
-            'name': name,
-            'comment': comment or '',
-            'items': self.items_buffer.chunks,
-            'cmdline': sys.argv,
-            'hostname': hostname,
-            'username': getuser(),
-            'time': start.strftime(ISO_FORMAT),
-            'time_end': end.strftime(ISO_FORMAT),
-            'chunker_params': self.chunker_params,
+            "version": 2,
+            "name": name,
+            "comment": comment or "",
+            "items": self.items_buffer.chunks,
+            "cmdline": sys.argv,
+            "hostname": hostname,
+            "username": getuser(),
+            "time": start.strftime(ISO_FORMAT),
+            "time_end": end.strftime(ISO_FORMAT),
+            "chunker_params": self.chunker_params,
         }
         if stats is not None:
-            metadata.update({
-                'size': stats.osize,
-                'nfiles': stats.nfiles,
-                'size_parts': stats.osize_parts,
-                'nfiles_parts': stats.nfiles_parts})
+            metadata.update(
+                {
+                    "size": stats.osize,
+                    "nfiles": stats.nfiles,
+                    "size_parts": stats.osize_parts,
+                    "nfiles_parts": stats.nfiles_parts,
+                }
+            )
         metadata.update(additional_metadata or {})
         metadata = ArchiveItem(metadata)
-        data = self.key.pack_and_authenticate_metadata(metadata.as_dict(), context=b'archive')
+        data = self.key.pack_and_authenticate_metadata(metadata.as_dict(), context=b"archive")
         self.id = self.key.id_hash(data)
         try:
             self.cache.add_chunk(self.id, data, self.stats)
         except IntegrityError as err:
             err_msg = str(err)
             # hack to avoid changing the RPC protocol by introducing new (more specific) exception class
-            if 'More than allowed put data' in err_msg:
-                raise Error('%s - archive too big (issue #1473)!' % err_msg)
+            if "More than allowed put data" in err_msg:
+                raise Error("%s - archive too big (issue #1473)!" % err_msg)
             else:
                 raise
         while self.repository.async_response(wait=True) is not None:
@@ -632,6 +653,7 @@ Utilization of max. archive size: {csize_max:.0%}
         if not want_unique:
             unique_size = 0
         else:
+
             def add(id):
                 entry = cache.chunks[id]
                 archive_index.add(id, 1, entry.size)
@@ -640,10 +662,12 @@ Utilization of max. archive size: {csize_max:.0%}
             sync = CacheSynchronizer(archive_index)
             add(self.id)
             # we must escape any % char in the archive name, because we use it in a format string, see #6500
-            arch_name_escd = self.name.replace('%', '%%')
-            pi = ProgressIndicatorPercent(total=len(self.metadata.items),
-                                          msg='Calculating statistics for archive %s ... %%3.0f%%%%' % arch_name_escd,
-                                          msgid='archive.calc_stats')
+            arch_name_escd = self.name.replace("%", "%%")
+            pi = ProgressIndicatorPercent(
+                total=len(self.metadata.items),
+                msg="Calculating statistics for archive %s ... %%3.0f%%%%" % arch_name_escd,
+                msgid="archive.calc_stats",
+            )
             for id, chunk in zip(self.metadata.items, self.repository.get_many(self.metadata.items)):
                 pi.show(increase=1)
                 add(id)
@@ -665,17 +689,17 @@ Utilization of max. archive size: {csize_max:.0%}
     def extract_helper(self, item, path, hlm, *, dry_run=False):
         hardlink_set = False
         # Hard link?
-        if 'hlid' in item:
+        if "hlid" in item:
             link_target = hlm.retrieve(id=item.hlid)
             if link_target is not None and has_link:
                 if not dry_run:
                     # another hardlink to same inode (same hlid) was extracted previously, just link to it
-                    with backup_io('link'):
+                    with backup_io("link"):
                         os.link(link_target, path, follow_symlinks=False)
                 hardlink_set = True
         yield hardlink_set
         if not hardlink_set:
-            if 'hlid' in item and has_link:
+            if "hlid" in item and has_link:
                 # Update entry with extracted item path, so that following hardlinks don't extract twice.
                 # We have hardlinking support, so we will hardlink not extract.
                 hlm.remember(id=item.hlid, info=path)
@@ -684,8 +708,18 @@ Utilization of max. archive size: {csize_max:.0%}
                 # In this case, we *want* to extract twice, because there is no other way.
                 pass
 
-    def extract_item(self, item, restore_attrs=True, dry_run=False, stdout=False, sparse=False,
-                     hlm=None, stripped_components=0, original_path=None, pi=None):
+    def extract_item(
+        self,
+        item,
+        restore_attrs=True,
+        dry_run=False,
+        stdout=False,
+        sparse=False,
+        hlm=None,
+        stripped_components=0,
+        original_path=None,
+        pi=None,
+    ):
         """
         Extract archive item.
 
@@ -699,14 +733,14 @@ Utilization of max. archive size: {csize_max:.0%}
         :param original_path: 'path' key as stored in archive
         :param pi: ProgressIndicatorPercent (or similar) for file extraction progress (in bytes)
         """
-        has_damaged_chunks = 'chunks_healthy' in item
+        has_damaged_chunks = "chunks_healthy" in item
         if dry_run or stdout:
-            with self.extract_helper(item, '', hlm, dry_run=dry_run or stdout) as hardlink_set:
+            with self.extract_helper(item, "", hlm, dry_run=dry_run or stdout) as hardlink_set:
                 if not hardlink_set:
                     # it does not really set hardlinks due to dry_run, but we need to behave same
                     # as non-dry_run concerning fetching preloaded chunks from the pipeline or
                     # it would get stuck.
-                    if 'chunks' in item:
+                    if "chunks" in item:
                         item_chunks_size = 0
                         for data in self.pipeline.fetch_many([c.id for c in item.chunks], is_preloaded=True):
                             if pi:
@@ -716,19 +750,22 @@ Utilization of max. archive size: {csize_max:.0%}
                             item_chunks_size += len(data)
                         if stdout:
                             sys.stdout.buffer.flush()
-                        if 'size' in item:
+                        if "size" in item:
                             item_size = item.size
                             if item_size != item_chunks_size:
-                                raise BackupError('Size inconsistency detected: size {}, chunks size {}'.format(
-                                                  item_size, item_chunks_size))
+                                raise BackupError(
+                                    "Size inconsistency detected: size {}, chunks size {}".format(
+                                        item_size, item_chunks_size
+                                    )
+                                )
             if has_damaged_chunks:
-                raise BackupError('File has damaged (all-zero) chunks. Try running borg check --repair.')
+                raise BackupError("File has damaged (all-zero) chunks. Try running borg check --repair.")
             return
 
         original_path = original_path or item.path
         dest = self.cwd
-        if item.path.startswith(('/', '../')):
-            raise Exception('Path should be relative and local')
+        if item.path.startswith(("/", "../")):
+            raise Exception("Path should be relative and local")
         path = os.path.join(dest, item.path)
         # Attempt to remove existing files, ignore errors on failure
         try:
@@ -749,36 +786,37 @@ Utilization of max. archive size: {csize_max:.0%}
 
         mode = item.mode
         if stat.S_ISREG(mode):
-            with backup_io('makedirs'):
+            with backup_io("makedirs"):
                 make_parent(path)
             with self.extract_helper(item, path, hlm) as hardlink_set:
                 if hardlink_set:
                     return
-                with backup_io('open'):
-                    fd = open(path, 'wb')
+                with backup_io("open"):
+                    fd = open(path, "wb")
                 with fd:
                     ids = [c.id for c in item.chunks]
                     for data in self.pipeline.fetch_many(ids, is_preloaded=True):
                         if pi:
                             pi.show(increase=len(data), info=[remove_surrogates(item.path)])
-                        with backup_io('write'):
+                        with backup_io("write"):
                             if sparse and zeros.startswith(data):
                                 # all-zero chunk: create a hole in a sparse file
                                 fd.seek(len(data), 1)
                             else:
                                 fd.write(data)
-                    with backup_io('truncate_and_attrs'):
+                    with backup_io("truncate_and_attrs"):
                         pos = item_chunks_size = fd.tell()
                         fd.truncate(pos)
                         fd.flush()
                         self.restore_attrs(path, item, fd=fd.fileno())
-                if 'size' in item:
+                if "size" in item:
                     item_size = item.size
                     if item_size != item_chunks_size:
-                        raise BackupError('Size inconsistency detected: size {}, chunks size {}'.format(
-                                          item_size, item_chunks_size))
+                        raise BackupError(
+                            "Size inconsistency detected: size {}, chunks size {}".format(item_size, item_chunks_size)
+                        )
                 if has_damaged_chunks:
-                    raise BackupError('File has damaged (all-zero) chunks. Try running borg check --repair.')
+                    raise BackupError("File has damaged (all-zero) chunks. Try running borg check --repair.")
             return
         with backup_io:
             # No repository access beyond this point.
@@ -815,7 +853,7 @@ Utilization of max. archive size: {csize_max:.0%}
                     os.mknod(path, item.mode, item.rdev)
                     self.restore_attrs(path, item)
             else:
-                raise Exception('Unknown archive item type %r' % item.mode)
+                raise Exception("Unknown archive item type %r" % item.mode)
 
     def restore_attrs(self, path, item, symlink=False, fd=None):
         """
@@ -823,7 +861,7 @@ Utilization of max. archive size: {csize_max:.0%}
 
         Does not access the repository.
         """
-        backup_io.op = 'attrs'
+        backup_io.op = "attrs"
         uid, gid = get_item_uid_gid(item, numeric=self.numeric_ids)
         # This code is a bit of a mess due to os specific differences
         if not is_win32:
@@ -849,12 +887,12 @@ Utilization of max. archive size: {csize_max:.0%}
                     if not symlink:
                         os.chmod(path, item.mode)
             mtime = item.mtime
-            if 'atime' in item:
+            if "atime" in item:
                 atime = item.atime
             else:
                 # old archives only had mtime in item metadata
                 atime = mtime
-            if 'birthtime' in item:
+            if "birthtime" in item:
                 birthtime = item.birthtime
                 try:
                     # This should work on FreeBSD, NetBSD, and Darwin and be harmless on other platforms.
@@ -879,11 +917,11 @@ Utilization of max. archive size: {csize_max:.0%}
             if not self.noxattrs:
                 # chown removes Linux capabilities, so set the extended attributes at the end, after chown, since they include
                 # the Linux capabilities in the "security.capability" attribute.
-                warning = xattr.set_all(fd or path, item.get('xattrs', {}), follow_symlinks=False)
+                warning = xattr.set_all(fd or path, item.get("xattrs", {}), follow_symlinks=False)
                 if warning:
                     set_ec(EXIT_WARNING)
             # bsdflags include the immutable flag and need to be set last:
-            if not self.noflags and 'bsdflags' in item:
+            if not self.noflags and "bsdflags" in item:
                 try:
                     set_flags(path, item.bsdflags, fd=fd)
                 except OSError:
@@ -904,7 +942,7 @@ Utilization of max. archive size: {csize_max:.0%}
             raise self.AlreadyExists(name)
         oldname = self.name
         self.name = name
-        self.set_meta('name', name)
+        self.set_meta("name", name)
         del self.manifest.archives[oldname]
 
     def delete(self, stats, progress=False, forced=False):
@@ -937,7 +975,9 @@ Utilization of max. archive size: {csize_max:.0%}
         try:
             unpacker = msgpack.Unpacker(use_list=False)
             items_ids = self.metadata.items
-            pi = ProgressIndicatorPercent(total=len(items_ids), msg="Decrementing references %3.0f%%", msgid='archive.delete')
+            pi = ProgressIndicatorPercent(
+                total=len(items_ids), msg="Decrementing references %3.0f%%", msgid="archive.delete"
+            )
             for (i, (items_id, data)) in enumerate(zip(items_ids, self.repository.get_many(items_ids))):
                 if progress:
                     pi.show(i)
@@ -947,8 +987,8 @@ Utilization of max. archive size: {csize_max:.0%}
                 try:
                     for item in unpacker:
                         item = Item(internal_dict=item)
-                        if 'chunks' in item:
-                            part = not self.consider_part_files and 'part' in item
+                        if "chunks" in item:
+                            part = not self.consider_part_files and "part" in item
                             for chunk_id, size in item.chunks:
                                 chunk_decref(chunk_id, stats, part=part)
                 except (TypeError, ValueError):
@@ -974,8 +1014,8 @@ Utilization of max. archive size: {csize_max:.0%}
             # so there is nothing pending when we return and our caller wants to commit.
             pass
         if error:
-            logger.warning('forced deletion succeeded, but the deleted archive was corrupted.')
-            logger.warning('borg check --repair is required to free all space.')
+            logger.warning("forced deletion succeeded, but the deleted archive was corrupted.")
+            logger.warning("borg check --repair is required to free all space.")
 
     @staticmethod
     def compare_archives_iter(archive1, archive2, matcher=None, can_compare_chunk_ids=False):
@@ -987,17 +1027,20 @@ Utilization of max. archive size: {csize_max:.0%}
         """
 
         def compare_items(item1, item2):
-            return ItemDiff(item1, item2,
-                            archive1.pipeline.fetch_many([c.id for c in item1.get('chunks', [])]),
-                            archive2.pipeline.fetch_many([c.id for c in item2.get('chunks', [])]),
-                            can_compare_chunk_ids=can_compare_chunk_ids)
+            return ItemDiff(
+                item1,
+                item2,
+                archive1.pipeline.fetch_many([c.id for c in item1.get("chunks", [])]),
+                archive2.pipeline.fetch_many([c.id for c in item2.get("chunks", [])]),
+                can_compare_chunk_ids=can_compare_chunk_ids,
+            )
 
         orphans_archive1 = OrderedDict()
         orphans_archive2 = OrderedDict()
 
         for item1, item2 in zip_longest(
-                archive1.iter_items(lambda item: matcher.match(item.path)),
-                archive2.iter_items(lambda item: matcher.match(item.path)),
+            archive1.iter_items(lambda item: matcher.match(item.path)),
+            archive2.iter_items(lambda item: matcher.match(item.path)),
         ):
             if item1 and item2 and item1.path == item2.path:
                 yield (item1.path, compare_items(item1, item2))
@@ -1036,42 +1079,37 @@ class MetadataCollector:
         self.nobirthtime = nobirthtime
 
     def stat_simple_attrs(self, st):
-        attrs = dict(
-            mode=st.st_mode,
-            uid=st.st_uid,
-            gid=st.st_gid,
-            mtime=safe_ns(st.st_mtime_ns),
-        )
+        attrs = dict(mode=st.st_mode, uid=st.st_uid, gid=st.st_gid, mtime=safe_ns(st.st_mtime_ns))
         # borg can work with archives only having mtime (older attic archives do not have
         # atime/ctime). it can be useful to omit atime/ctime, if they change without the
         # file content changing - e.g. to get better metadata deduplication.
         if not self.noatime:
-            attrs['atime'] = safe_ns(st.st_atime_ns)
+            attrs["atime"] = safe_ns(st.st_atime_ns)
         if not self.noctime:
-            attrs['ctime'] = safe_ns(st.st_ctime_ns)
-        if not self.nobirthtime and hasattr(st, 'st_birthtime'):
+            attrs["ctime"] = safe_ns(st.st_ctime_ns)
+        if not self.nobirthtime and hasattr(st, "st_birthtime"):
             # sadly, there's no stat_result.st_birthtime_ns
-            attrs['birthtime'] = safe_ns(int(st.st_birthtime * 10**9))
+            attrs["birthtime"] = safe_ns(int(st.st_birthtime * 10**9))
         if not self.numeric_ids:
             user = uid2user(st.st_uid)
             if user is not None:
-                attrs['user'] = user
+                attrs["user"] = user
             group = gid2group(st.st_gid)
             if group is not None:
-                attrs['group'] = group
+                attrs["group"] = group
         return attrs
 
     def stat_ext_attrs(self, st, path, fd=None):
         attrs = {}
-        with backup_io('extended stat'):
+        with backup_io("extended stat"):
             flags = 0 if self.noflags else get_flags(path, st, fd=fd)
             xattrs = {} if self.noxattrs else xattr.get_all(fd or path, follow_symlinks=False)
             if not self.noacls:
                 acl_get(path, attrs, st, self.numeric_ids, fd=fd)
         if xattrs:
-            attrs['xattrs'] = StableDict(xattrs)
+            attrs["xattrs"] = StableDict(xattrs)
         if flags:
-            attrs['bsdflags'] = flags
+            attrs["bsdflags"] = flags
         return attrs
 
     def stat_attrs(self, st, path, fd=None):
@@ -1088,12 +1126,12 @@ zero_chunk_ids = LRUCache(10, dispose=lambda _: None)
 
 
 def cached_hash(chunk, id_hash):
-    allocation = chunk.meta['allocation']
+    allocation = chunk.meta["allocation"]
     if allocation == CH_DATA:
         data = chunk.data
         chunk_id = id_hash(data)
     elif allocation in (CH_HOLE, CH_ALLOC):
-        size = chunk.meta['size']
+        size = chunk.meta["size"]
         assert size <= len(zeros)
         data = memoryview(zeros)[:size]
         try:
@@ -1102,16 +1140,14 @@ def cached_hash(chunk, id_hash):
             chunk_id = id_hash(data)
             zero_chunk_ids[(id_hash, size)] = chunk_id
     else:
-        raise ValueError('unexpected allocation type')
+        raise ValueError("unexpected allocation type")
     return chunk_id, data
 
 
 class ChunksProcessor:
     # Processes an iterator of chunks for an Item
 
-    def __init__(self, *, key, cache,
-                 add_item, write_checkpoint,
-                 checkpoint_interval, rechunkify):
+    def __init__(self, *, key, cache, add_item, write_checkpoint, checkpoint_interval, rechunkify):
         self.key = key
         self.cache = cache
         self.add_item = add_item
@@ -1128,7 +1164,7 @@ class ChunksProcessor:
         # for borg recreate, we already have a size member in the source item (giving the total file size),
         # but we consider only a part of the file here, thus we must recompute the size from the chunks:
         item.get_size(memorize=True, from_chunks=True)
-        item.path += '.borg_part_%d' % number
+        item.path += ".borg_part_%d" % number
         item.part = number
         number += 1
         self.add_item(item, show_progress=False)
@@ -1137,19 +1173,24 @@ class ChunksProcessor:
 
     def maybe_checkpoint(self, item, from_chunk, part_number, forced=False):
         sig_int_triggered = sig_int and sig_int.action_triggered()
-        if forced or sig_int_triggered or \
-            self.checkpoint_interval and time.monotonic() - self.last_checkpoint > self.checkpoint_interval:
+        if (
+            forced
+            or sig_int_triggered
+            or self.checkpoint_interval
+            and time.monotonic() - self.last_checkpoint > self.checkpoint_interval
+        ):
             if sig_int_triggered:
-                logger.info('checkpoint requested: starting checkpoint creation...')
+                logger.info("checkpoint requested: starting checkpoint creation...")
             from_chunk, part_number = self.write_part_file(item, from_chunk, part_number)
             self.last_checkpoint = time.monotonic()
             if sig_int_triggered:
                 sig_int.action_completed()
-                logger.info('checkpoint requested: finished checkpoint creation!')
+                logger.info("checkpoint requested: finished checkpoint creation!")
         return from_chunk, part_number
 
     def process_file_chunks(self, item, cache, stats, show_progress, chunk_iter, chunk_processor=None):
         if not chunk_processor:
+
             def chunk_processor(chunk):
                 chunk_id, data = cached_hash(chunk, self.key.id_hash)
                 chunk_entry = cache.add_chunk(chunk_id, data, stats, wait=False)
@@ -1159,7 +1200,7 @@ class ChunksProcessor:
         item.chunks = []
         # if we rechunkify, we'll get a fundamentally different chunks list, thus we need
         # to get rid of .chunks_healthy, as it might not correspond to .chunks any more.
-        if self.rechunkify and 'chunks_healthy' in item:
+        if self.rechunkify and "chunks_healthy" in item:
             del item.chunks_healthy
         from_chunk = 0
         part_number = 1
@@ -1188,10 +1229,21 @@ class FilesystemObjectProcessors:
     # write_checkpoint should then be in the item buffer,
     # and process_file becomes a callback passed to __init__.
 
-    def __init__(self, *, metadata_collector, cache, key,
-                 add_item, process_file_chunks,
-                 chunker_params, show_progress, sparse,
-                 log_json, iec, file_status_printer=None):
+    def __init__(
+        self,
+        *,
+        metadata_collector,
+        cache,
+        key,
+        add_item,
+        process_file_chunks,
+        chunker_params,
+        show_progress,
+        sparse,
+        log_json,
+        iec,
+        file_status_printer=None,
+    ):
         self.metadata_collector = metadata_collector
         self.cache = cache
         self.key = key
@@ -1212,7 +1264,7 @@ class FilesystemObjectProcessors:
         hardlinked = hardlinkable and st.st_nlink > 1
         update_map = False
         if hardlinked:
-            status = 'h'  # hardlink
+            status = "h"  # hardlink
             nothing = object()
             chunks = self.hlm.retrieve(id=(st.st_ino, st.st_dev), default=nothing)
             if chunks is nothing:
@@ -1225,29 +1277,28 @@ class FilesystemObjectProcessors:
         if update_map:
             # remember the hlid of this fs object and if the item has chunks,
             # also remember them, so we do not have to re-chunk a hardlink.
-            chunks = item.chunks if 'chunks' in item else None
+            chunks = item.chunks if "chunks" in item else None
             self.hlm.remember(id=(st.st_ino, st.st_dev), info=chunks)
 
     def process_dir_with_fd(self, *, path, fd, st):
-        with self.create_helper(path, st, 'd', hardlinkable=False) as (item, status, hardlinked):
+        with self.create_helper(path, st, "d", hardlinkable=False) as (item, status, hardlinked):
             item.update(self.metadata_collector.stat_attrs(st, path, fd=fd))
             return status
 
     def process_dir(self, *, path, parent_fd, name, st):
-        with self.create_helper(path, st, 'd', hardlinkable=False) as (item, status, hardlinked):
-            with OsOpen(path=path, parent_fd=parent_fd, name=name, flags=flags_dir,
-                        noatime=True, op='dir_open') as fd:
+        with self.create_helper(path, st, "d", hardlinkable=False) as (item, status, hardlinked):
+            with OsOpen(path=path, parent_fd=parent_fd, name=name, flags=flags_dir, noatime=True, op="dir_open") as fd:
                 # fd is None for directories on windows, in that case a race condition check is not possible.
                 if fd is not None:
-                    with backup_io('fstat'):
+                    with backup_io("fstat"):
                         st = stat_update_check(st, os.fstat(fd))
                 item.update(self.metadata_collector.stat_attrs(st, path, fd=fd))
                 return status
 
     def process_fifo(self, *, path, parent_fd, name, st):
-        with self.create_helper(path, st, 'f') as (item, status, hardlinked):  # fifo
+        with self.create_helper(path, st, "f") as (item, status, hardlinked):  # fifo
             with OsOpen(path=path, parent_fd=parent_fd, name=name, flags=flags_normal, noatime=True) as fd:
-                with backup_io('fstat'):
+                with backup_io("fstat"):
                     st = stat_update_check(st, os.fstat(fd))
                 item.update(self.metadata_collector.stat_attrs(st, path, fd=fd))
                 return status
@@ -1255,23 +1306,23 @@ class FilesystemObjectProcessors:
     def process_dev(self, *, path, parent_fd, name, st, dev_type):
         with self.create_helper(path, st, dev_type) as (item, status, hardlinked):  # char/block device
             # looks like we can not work fd-based here without causing issues when trying to open/close the device
-            with backup_io('stat'):
+            with backup_io("stat"):
                 st = stat_update_check(st, os_stat(path=path, parent_fd=parent_fd, name=name, follow_symlinks=False))
             item.rdev = st.st_rdev
             item.update(self.metadata_collector.stat_attrs(st, path))
             return status
 
     def process_symlink(self, *, path, parent_fd, name, st):
-        with self.create_helper(path, st, 's', hardlinkable=True) as (item, status, hardlinked):
+        with self.create_helper(path, st, "s", hardlinkable=True) as (item, status, hardlinked):
             fname = name if name is not None and parent_fd is not None else path
-            with backup_io('readlink'):
+            with backup_io("readlink"):
                 source = os.readlink(fname, dir_fd=parent_fd)
             item.source = source
             item.update(self.metadata_collector.stat_attrs(st, path))  # can't use FD here?
             return status
 
     def process_pipe(self, *, path, cache, fd, mode, user, group):
-        status = 'i'  # stdin (or other pipe)
+        status = "i"  # stdin (or other pipe)
         self.print_file_status(status, path)
         status = None  # we already printed the status
         uid = user2uid(user)
@@ -1284,9 +1335,13 @@ class FilesystemObjectProcessors:
         item = Item(
             path=path,
             mode=mode & 0o107777 | 0o100000,  # forcing regular file mode
-            uid=uid, user=user,
-            gid=gid, group=group,
-            mtime=t, atime=t, ctime=t,
+            uid=uid,
+            user=user,
+            gid=gid,
+            group=group,
+            mtime=t,
+            atime=t,
+            ctime=t,
         )
         self.process_file_chunks(item, cache, self.stats, self.show_progress, backup_io_iter(self.chunker.chunkify(fd)))
         item.get_size(memorize=True)
@@ -1297,7 +1352,7 @@ class FilesystemObjectProcessors:
     def process_file(self, *, path, parent_fd, name, st, cache, flags=flags_normal):
         with self.create_helper(path, st, None) as (item, status, hardlinked):  # no status yet
             with OsOpen(path=path, parent_fd=parent_fd, name=name, flags=flags, noatime=True) as fd:
-                with backup_io('fstat'):
+                with backup_io("fstat"):
                     st = stat_update_check(st, os.fstat(fd))
                 item.update(self.metadata_collector.stat_simple_attrs(st))
                 is_special_file = is_special(st.st_mode)
@@ -1306,7 +1361,7 @@ class FilesystemObjectProcessors:
                     # so it can be extracted / accessed in FUSE mount like a regular file.
                     # this needs to be done early, so that part files also get the patched mode.
                     item.mode = stat.S_IFREG | stat.S_IMODE(item.mode)
-                if 'chunks' in item:  # create_helper might have put chunks from a previous hardlink there
+                if "chunks" in item:  # create_helper might have put chunks from a previous hardlink there
                     [cache.chunk_incref(id_, self.stats) for id_, _ in item.chunks]
                 else:  # normal case, no "2nd+" hardlink
                     if not is_special_file:
@@ -1324,32 +1379,40 @@ class FilesystemObjectProcessors:
                         # Make sure all ids are available
                         for id_ in ids:
                             if not cache.seen_chunk(id_):
-                                status = 'M'  # cache said it is unmodified, but we lost a chunk: process file like modified
+                                status = (
+                                    "M"  # cache said it is unmodified, but we lost a chunk: process file like modified
+                                )
                                 break
                         else:
                             chunks = [cache.chunk_incref(id_, self.stats) for id_ in ids]
-                            status = 'U'  # regular file, unchanged
+                            status = "U"  # regular file, unchanged
                     else:
-                        status = 'M' if known else 'A'  # regular file, modified or added
+                        status = "M" if known else "A"  # regular file, modified or added
                     self.print_file_status(status, path)
                     status = None  # we already printed the status
                     # Only chunkify the file if needed
                     if chunks is not None:
                         item.chunks = chunks
                     else:
-                        with backup_io('read'):
-                            self.process_file_chunks(item, cache, self.stats, self.show_progress, backup_io_iter(self.chunker.chunkify(None, fd)))
+                        with backup_io("read"):
+                            self.process_file_chunks(
+                                item,
+                                cache,
+                                self.stats,
+                                self.show_progress,
+                                backup_io_iter(self.chunker.chunkify(None, fd)),
+                            )
                         if is_win32:
                             changed_while_backup = False  # TODO
                         else:
-                            with backup_io('fstat2'):
+                            with backup_io("fstat2"):
                                 st2 = os.fstat(fd)
                             # special files:
                             # - fifos change naturally, because they are fed from the other side. no problem.
                             # - blk/chr devices don't change ctime anyway.
                             changed_while_backup = not is_special_file and st.st_ctime_ns != st2.st_ctime_ns
                         if changed_while_backup:
-                            status = 'C'  # regular file changed while we backed it up, might be inconsistent/corrupt!
+                            status = "C"  # regular file changed while we backed it up, might be inconsistent/corrupt!
                         if not is_special_file and not changed_while_backup:
                             # we must not memorize special files, because the contents of e.g. a
                             # block or char device will change without its mtime/size/inode changing.
@@ -1363,10 +1426,19 @@ class FilesystemObjectProcessors:
 
 
 class TarfileObjectProcessors:
-    def __init__(self, *, cache, key,
-                 add_item, process_file_chunks,
-                 chunker_params, show_progress,
-                 log_json, iec, file_status_printer=None):
+    def __init__(
+        self,
+        *,
+        cache,
+        key,
+        add_item,
+        process_file_chunks,
+        chunker_params,
+        show_progress,
+        log_json,
+        iec,
+        file_status_printer=None,
+    ):
         self.cache = cache
         self.key = key
         self.add_item = add_item
@@ -1381,17 +1453,23 @@ class TarfileObjectProcessors:
     @contextmanager
     def create_helper(self, tarinfo, status=None, type=None):
         ph = tarinfo.pax_headers
-        if ph and 'BORG.item.version' in ph:
-            assert ph['BORG.item.version'] == '1'
-            meta_bin = base64.b64decode(ph['BORG.item.meta'])
+        if ph and "BORG.item.version" in ph:
+            assert ph["BORG.item.version"] == "1"
+            meta_bin = base64.b64decode(ph["BORG.item.meta"])
             meta_dict = msgpack.unpackb(meta_bin, object_hook=StableDict)
             item = Item(internal_dict=meta_dict)
         else:
+
             def s_to_ns(s):
                 return safe_ns(int(float(s) * 1e9))
 
-            item = Item(path=make_path_safe(tarinfo.name), mode=tarinfo.mode | type,
-                        uid=tarinfo.uid, gid=tarinfo.gid, mtime=s_to_ns(tarinfo.mtime))
+            item = Item(
+                path=make_path_safe(tarinfo.name),
+                mode=tarinfo.mode | type,
+                uid=tarinfo.uid,
+                gid=tarinfo.gid,
+                mtime=s_to_ns(tarinfo.mtime),
+            )
             if tarinfo.uname:
                 item.user = tarinfo.uname
             if tarinfo.gname:
@@ -1399,7 +1477,7 @@ class TarfileObjectProcessors:
             if ph:
                 # note: for mtime this is a bit redundant as it is already done by tarfile module,
                 #       but we just do it in our way to be consistent for sure.
-                for name in 'atime', 'ctime', 'mtime':
+                for name in "atime", "ctime", "mtime":
                     if name in ph:
                         ns = s_to_ns(ph[name])
                         setattr(item, name, ns)
@@ -1440,8 +1518,9 @@ class TarfileObjectProcessors:
             self.print_file_status(status, tarinfo.name)
             status = None  # we already printed the status
             fd = tar.extractfile(tarinfo)
-            self.process_file_chunks(item, self.cache, self.stats, self.show_progress,
-                                     backup_io_iter(self.chunker.chunkify(fd)))
+            self.process_file_chunks(
+                item, self.cache, self.stats, self.show_progress, backup_io_iter(self.chunker.chunkify(fd))
+            )
             item.get_size(memorize=True, from_chunks=True)
             self.stats.nfiles += 1
             # we need to remember ALL files, see HardLinkManager.__doc__
@@ -1454,9 +1533,9 @@ def valid_msgpacked_dict(d, keys_serialized):
     d_len = len(d)
     if d_len == 0:
         return False
-    if d[0] & 0xf0 == 0x80:  # object is a fixmap (up to 15 elements)
+    if d[0] & 0xF0 == 0x80:  # object is a fixmap (up to 15 elements)
         offs = 1
-    elif d[0] == 0xde:  # object is a map16 (up to 2^16-1 elements)
+    elif d[0] == 0xDE:  # object is a map16 (up to 2^16-1 elements)
         offs = 3
     else:
         # object is not a map (dict)
@@ -1465,9 +1544,9 @@ def valid_msgpacked_dict(d, keys_serialized):
     if d_len <= offs:
         return False
     # is the first dict key a bytestring?
-    if d[offs] & 0xe0 == 0xa0:  # key is a small bytestring (up to 31 chars)
+    if d[offs] & 0xE0 == 0xA0:  # key is a small bytestring (up to 31 chars)
         pass
-    elif d[offs] in (0xd9, 0xda, 0xdb):  # key is a str8, str16 or str32
+    elif d[offs] in (0xD9, 0xDA, 0xDB):  # key is a str8, str16 or str32
         pass
     else:
         # key is not a bytestring
@@ -1478,8 +1557,8 @@ def valid_msgpacked_dict(d, keys_serialized):
 
 
 class RobustUnpacker:
-    """A restartable/robust version of the streaming msgpack unpacker
-    """
+    """A restartable/robust version of the streaming msgpack unpacker"""
+
     def __init__(self, validator, item_keys):
         super().__init__()
         self.item_keys = [msgpack.packb(name) for name in item_keys]
@@ -1503,7 +1582,7 @@ class RobustUnpacker:
 
     def __next__(self):
         if self._resync:
-            data = b''.join(self._buffered_data)
+            data = b"".join(self._buffered_data)
             while self._resync:
                 if not data:
                     raise StopIteration
@@ -1528,13 +1607,13 @@ class RobustUnpacker:
 
 
 class ArchiveChecker:
-
     def __init__(self):
         self.error_found = False
         self.possibly_superseded = set()
 
-    def check(self, repository, repair=False, first=0, last=0, sort_by='', glob=None,
-              verify_data=False, save_space=False):
+    def check(
+        self, repository, repair=False, first=0, last=0, sort_by="", glob=None, verify_data=False, save_space=False
+    ):
         """Perform a set of checks on 'repository'
 
         :param repair: enable repair mode, write updated or corrected data into repository
@@ -1543,13 +1622,13 @@ class ArchiveChecker:
         :param verify_data: integrity verification of data referenced by archives
         :param save_space: Repository.commit(save_space)
         """
-        logger.info('Starting archive consistency check...')
+        logger.info("Starting archive consistency check...")
         self.check_all = not any((first, last, glob))
         self.repair = repair
         self.repository = repository
         self.init_chunks()
         if not self.chunks:
-            logger.error('Repository contains no apparent data at all, cannot continue check/repair.')
+            logger.error("Repository contains no apparent data at all, cannot continue check/repair.")
             return False
         self.key = self.identify_key(repository)
         if verify_data:
@@ -1562,7 +1641,7 @@ class ArchiveChecker:
             try:
                 self.manifest, _ = Manifest.load(repository, (Manifest.Operation.CHECK,), key=self.key)
             except IntegrityErrorBase as exc:
-                logger.error('Repository manifest is corrupted: %s', exc)
+                logger.error("Repository manifest is corrupted: %s", exc)
                 self.error_found = True
                 del self.chunks[Manifest.MANIFEST_ID]
                 self.manifest = self.rebuild_manifest()
@@ -1570,14 +1649,13 @@ class ArchiveChecker:
         self.orphan_chunks_check()
         self.finish(save_space=save_space)
         if self.error_found:
-            logger.error('Archive consistency check complete, problems found.')
+            logger.error("Archive consistency check complete, problems found.")
         else:
-            logger.info('Archive consistency check complete, no problems found.')
+            logger.info("Archive consistency check complete, no problems found.")
         return self.repair or not self.error_found
 
     def init_chunks(self):
-        """Fetch a list of all object keys from repository
-        """
+        """Fetch a list of all object keys from repository"""
         # Explicitly set the initial usable hash table capacity to avoid performance issues
         # due to hash table "resonance".
         # Since reconstruction of archive items can add some new chunks, add 10 % headroom.
@@ -1602,13 +1680,14 @@ class ArchiveChecker:
         return key_factory(repository, cdata)
 
     def verify_data(self):
-        logger.info('Starting cryptographic data integrity verification...')
+        logger.info("Starting cryptographic data integrity verification...")
         chunks_count_index = len(self.chunks)
         chunks_count_segments = 0
         errors = 0
         defect_chunks = []
-        pi = ProgressIndicatorPercent(total=chunks_count_index, msg="Verifying data %6.2f%%", step=0.01,
-                                      msgid='check.verify_data')
+        pi = ProgressIndicatorPercent(
+            total=chunks_count_index, msg="Verifying data %6.2f%%", step=0.01, msgid="check.verify_data"
+        )
         marker = None
         while True:
             chunk_ids = self.repository.scan(limit=100, marker=marker)
@@ -1626,7 +1705,7 @@ class ArchiveChecker:
                 except (Repository.ObjectNotFound, IntegrityErrorBase) as err:
                     self.error_found = True
                     errors += 1
-                    logger.error('chunk %s: %s', bin_to_hex(chunk_id), err)
+                    logger.error("chunk %s: %s", bin_to_hex(chunk_id), err)
                     if isinstance(err, IntegrityErrorBase):
                         defect_chunks.append(chunk_id)
                     # as the exception killed our generator, make a new one for remaining chunks:
@@ -1639,13 +1718,14 @@ class ArchiveChecker:
                     except IntegrityErrorBase as integrity_error:
                         self.error_found = True
                         errors += 1
-                        logger.error('chunk %s, integrity error: %s', bin_to_hex(chunk_id), integrity_error)
+                        logger.error("chunk %s, integrity error: %s", bin_to_hex(chunk_id), integrity_error)
                         defect_chunks.append(chunk_id)
         pi.finish()
         if chunks_count_index != chunks_count_segments:
-            logger.error('Repo/Chunks index object count vs. segment files object count mismatch.')
-            logger.error('Repo/Chunks index: %d objects != segment files: %d objects',
-                         chunks_count_index, chunks_count_segments)
+            logger.error("Repo/Chunks index object count vs. segment files object count mismatch.")
+            logger.error(
+                "Repo/Chunks index: %d objects != segment files: %d objects", chunks_count_index, chunks_count_segments
+            )
         if defect_chunks:
             if self.repair:
                 # if we kill the defect chunk here, subsequent actions within this "borg check"
@@ -1653,8 +1733,10 @@ class ArchiveChecker:
                 # chunks and flag the files as "repaired".
                 # if another backup is done later and the missing chunks get backupped again,
                 # a "borg check" afterwards can heal all files where this chunk was missing.
-                logger.warning('Found defect chunks. They will be deleted now, so affected files can '
-                               'get repaired now and maybe healed later.')
+                logger.warning(
+                    "Found defect chunks. They will be deleted now, so affected files can "
+                    "get repaired now and maybe healed later."
+                )
                 for defect_chunk in defect_chunks:
                     # remote repo (ssh): retry might help for strange network / NIC / RAM errors
                     # as the chunk will be retransmitted from remote server.
@@ -1668,29 +1750,35 @@ class ArchiveChecker:
                         # failed twice -> get rid of this chunk
                         del self.chunks[defect_chunk]
                         self.repository.delete(defect_chunk)
-                        logger.debug('chunk %s deleted.', bin_to_hex(defect_chunk))
+                        logger.debug("chunk %s deleted.", bin_to_hex(defect_chunk))
                     else:
-                        logger.warning('chunk %s not deleted, did not consistently fail.', bin_to_hex(defect_chunk))
+                        logger.warning("chunk %s not deleted, did not consistently fail.", bin_to_hex(defect_chunk))
             else:
-                logger.warning('Found defect chunks. With --repair, they would get deleted, so affected '
-                               'files could get repaired then and maybe healed later.')
+                logger.warning(
+                    "Found defect chunks. With --repair, they would get deleted, so affected "
+                    "files could get repaired then and maybe healed later."
+                )
                 for defect_chunk in defect_chunks:
-                    logger.debug('chunk %s is defect.', bin_to_hex(defect_chunk))
+                    logger.debug("chunk %s is defect.", bin_to_hex(defect_chunk))
         log = logger.error if errors else logger.info
-        log('Finished cryptographic data integrity verification, verified %d chunks with %d integrity errors.',
-            chunks_count_segments, errors)
+        log(
+            "Finished cryptographic data integrity verification, verified %d chunks with %d integrity errors.",
+            chunks_count_segments,
+            errors,
+        )
 
     def rebuild_manifest(self):
         """Rebuild the manifest object if it is missing
 
         Iterates through all objects in the repository looking for archive metadata blocks.
         """
+
         def valid_archive(obj):
             if not isinstance(obj, dict):
                 return False
             return REQUIRED_ARCHIVE_KEYS.issubset(obj)
 
-        logger.info('Rebuilding missing manifest, this might take some time...')
+        logger.info("Rebuilding missing manifest, this might take some time...")
         # as we have lost the manifest, we do not know any more what valid item keys we had.
         # collecting any key we encounter in a damaged repo seems unwise, thus we just use
         # the hardcoded list from the source code. thus, it is not recommended to rebuild a
@@ -1698,20 +1786,21 @@ class ArchiveChecker:
         # within this repository (assuming that newer borg versions support more item keys).
         manifest = Manifest(self.key, self.repository)
         archive_keys_serialized = [msgpack.packb(name) for name in ARCHIVE_KEYS]
-        pi = ProgressIndicatorPercent(total=len(self.chunks), msg="Rebuilding manifest %6.2f%%", step=0.01,
-                                      msgid='check.rebuild_manifest')
+        pi = ProgressIndicatorPercent(
+            total=len(self.chunks), msg="Rebuilding manifest %6.2f%%", step=0.01, msgid="check.rebuild_manifest"
+        )
         for chunk_id, _ in self.chunks.iteritems():
             pi.show()
             cdata = self.repository.get(chunk_id)
             try:
                 data = self.key.decrypt(chunk_id, cdata)
             except IntegrityErrorBase as exc:
-                logger.error('Skipping corrupted chunk: %s', exc)
+                logger.error("Skipping corrupted chunk: %s", exc)
                 self.error_found = True
                 continue
             if not valid_msgpacked_dict(data, archive_keys_serialized):
                 continue
-            if b'cmdline' not in data or b'\xa7version\x02' not in data:
+            if b"cmdline" not in data or b"\xa7version\x02" not in data:
                 continue
             try:
                 archive = msgpack.unpackb(data)
@@ -1721,22 +1810,22 @@ class ArchiveChecker:
             if valid_archive(archive):
                 archive = ArchiveItem(internal_dict=archive)
                 name = archive.name
-                logger.info('Found archive %s', name)
+                logger.info("Found archive %s", name)
                 if name in manifest.archives:
                     i = 1
                     while True:
-                        new_name = '%s.%d' % (name, i)
+                        new_name = "%s.%d" % (name, i)
                         if new_name not in manifest.archives:
                             break
                         i += 1
-                    logger.warning('Duplicate archive name %s, storing as %s', name, new_name)
+                    logger.warning("Duplicate archive name %s, storing as %s", name, new_name)
                     name = new_name
                 manifest.archives[name] = (chunk_id, archive.time)
         pi.finish()
-        logger.info('Manifest rebuild complete.')
+        logger.info("Manifest rebuild complete.")
         return manifest
 
-    def rebuild_refcounts(self, first=0, last=0, sort_by='', glob=None):
+    def rebuild_refcounts(self, first=0, last=0, sort_by="", glob=None):
         """Rebuild object reference counts by walking the metadata
 
         Missing and/or incorrect data is repaired when detected
@@ -1769,6 +1858,7 @@ class ArchiveChecker:
             Missing file chunks will be replaced with new chunks of the same length containing all zeros.
             If a previously missing file chunk re-appears, the replacement chunk is replaced by the correct one.
             """
+
             def replacement_chunk(size):
                 chunk = Chunk(None, allocation=CH_ALLOC, size=size)
                 chunk_id, data = cached_hash(chunk, self.key.id_hash)
@@ -1778,12 +1868,12 @@ class ArchiveChecker:
             offset = 0
             chunk_list = []
             chunks_replaced = False
-            has_chunks_healthy = 'chunks_healthy' in item
+            has_chunks_healthy = "chunks_healthy" in item
             chunks_current = item.chunks
             chunks_healthy = item.chunks_healthy if has_chunks_healthy else chunks_current
             if has_chunks_healthy and len(chunks_current) != len(chunks_healthy):
                 # should never happen, but there was issue #3218.
-                logger.warning(f'{archive_name}: {item.path}: Invalid chunks_healthy metadata removed!')
+                logger.warning(f"{archive_name}: {item.path}: Invalid chunks_healthy metadata removed!")
                 del item.chunks_healthy
                 has_chunks_healthy = False
                 chunks_healthy = chunks_current
@@ -1792,23 +1882,32 @@ class ArchiveChecker:
                 if chunk_id not in self.chunks:
                     # a chunk of the healthy list is missing
                     if chunk_current == chunk_healthy:
-                        logger.error('{}: {}: New missing file chunk detected (Byte {}-{}, Chunk {}). '
-                                     'Replacing with all-zero chunk.'.format(
-                                     archive_name, item.path, offset, offset + size, bin_to_hex(chunk_id)))
+                        logger.error(
+                            "{}: {}: New missing file chunk detected (Byte {}-{}, Chunk {}). "
+                            "Replacing with all-zero chunk.".format(
+                                archive_name, item.path, offset, offset + size, bin_to_hex(chunk_id)
+                            )
+                        )
                         self.error_found = chunks_replaced = True
                         chunk_id, size, cdata = replacement_chunk(size)
                         add_reference(chunk_id, size, cdata)
                     else:
-                        logger.info('{}: {}: Previously missing file chunk is still missing (Byte {}-{}, Chunk {}). '
-                                    'It has an all-zero replacement chunk already.'.format(
-                                    archive_name, item.path, offset, offset + size, bin_to_hex(chunk_id)))
+                        logger.info(
+                            "{}: {}: Previously missing file chunk is still missing (Byte {}-{}, Chunk {}). "
+                            "It has an all-zero replacement chunk already.".format(
+                                archive_name, item.path, offset, offset + size, bin_to_hex(chunk_id)
+                            )
+                        )
                         chunk_id, size = chunk_current
                         if chunk_id in self.chunks:
                             add_reference(chunk_id, size)
                         else:
-                            logger.warning('{}: {}: Missing all-zero replacement chunk detected (Byte {}-{}, Chunk {}). '
-                                           'Generating new replacement chunk.'.format(
-                                           archive_name, item.path, offset, offset + size, bin_to_hex(chunk_id)))
+                            logger.warning(
+                                "{}: {}: Missing all-zero replacement chunk detected (Byte {}-{}, Chunk {}). "
+                                "Generating new replacement chunk.".format(
+                                    archive_name, item.path, offset, offset + size, bin_to_hex(chunk_id)
+                                )
+                            )
                             self.error_found = chunks_replaced = True
                             chunk_id, size, cdata = replacement_chunk(size)
                             add_reference(chunk_id, size, cdata)
@@ -1817,8 +1916,11 @@ class ArchiveChecker:
                         # normal case, all fine.
                         add_reference(chunk_id, size)
                     else:
-                        logger.info('{}: {}: Healed previously missing file chunk! (Byte {}-{}, Chunk {}).'.format(
-                            archive_name, item.path, offset, offset + size, bin_to_hex(chunk_id)))
+                        logger.info(
+                            "{}: {}: Healed previously missing file chunk! (Byte {}-{}, Chunk {}).".format(
+                                archive_name, item.path, offset, offset + size, bin_to_hex(chunk_id)
+                            )
+                        )
                         add_reference(chunk_id, size)
                         mark_as_possibly_superseded(chunk_current[0])  # maybe orphaned the all-zero replacement chunk
                 chunk_list.append([chunk_id, size])  # list-typed element as chunks_healthy is list-of-lists
@@ -1827,16 +1929,19 @@ class ArchiveChecker:
                 # if this is first repair, remember the correct chunk IDs, so we can maybe heal the file later
                 item.chunks_healthy = item.chunks
             if has_chunks_healthy and chunk_list == chunks_healthy:
-                logger.info(f'{archive_name}: {item.path}: Completely healed previously damaged file!')
+                logger.info(f"{archive_name}: {item.path}: Completely healed previously damaged file!")
                 del item.chunks_healthy
             item.chunks = chunk_list
-            if 'size' in item:
+            if "size" in item:
                 item_size = item.size
                 item_chunks_size = item.get_size(from_chunks=True)
                 if item_size != item_chunks_size:
                     # just warn, but keep the inconsistency, so that borg extract can warn about it.
-                    logger.warning('{}: {}: size inconsistency detected: size {}, chunks size {}'.format(
-                                   archive_name, item.path, item_size, item_chunks_size))
+                    logger.warning(
+                        "{}: {}: size inconsistency detected: size {}, chunks size {}".format(
+                            archive_name, item.path, item_size, item_chunks_size
+                        )
+                    )
 
         def robust_iterator(archive):
             """Iterates through all archive items
@@ -1845,8 +1950,9 @@ class ArchiveChecker:
             """
             item_keys = self.manifest.item_keys
             required_item_keys = REQUIRED_ITEM_KEYS
-            unpacker = RobustUnpacker(lambda item: isinstance(item, StableDict) and 'path' in item,
-                                      self.manifest.item_keys)
+            unpacker = RobustUnpacker(
+                lambda item: isinstance(item, StableDict) and "path" in item, self.manifest.item_keys
+            )
             _state = 0
 
             def missing_chunk_detector(chunk_id):
@@ -1857,29 +1963,29 @@ class ArchiveChecker:
 
             def report(msg, chunk_id, chunk_no):
                 cid = bin_to_hex(chunk_id)
-                msg += ' [chunk: %06d_%s]' % (chunk_no, cid)  # see "debug dump-archive-items"
+                msg += " [chunk: %06d_%s]" % (chunk_no, cid)  # see "debug dump-archive-items"
                 self.error_found = True
                 logger.error(msg)
 
             def list_keys_safe(keys):
-                return ', '.join(k.decode(errors='replace') if isinstance(k, bytes) else str(k) for k in keys)
+                return ", ".join(k.decode(errors="replace") if isinstance(k, bytes) else str(k) for k in keys)
 
             def valid_item(obj):
                 if not isinstance(obj, StableDict):
-                    return False, 'not a dictionary'
+                    return False, "not a dictionary"
                 keys = set(obj)
                 if not required_item_keys.issubset(keys):
-                    return False, 'missing required keys: ' + list_keys_safe(required_item_keys - keys)
+                    return False, "missing required keys: " + list_keys_safe(required_item_keys - keys)
                 if not keys.issubset(item_keys):
-                    return False, 'invalid keys: ' + list_keys_safe(keys - item_keys)
-                return True, ''
+                    return False, "invalid keys: " + list_keys_safe(keys - item_keys)
+                return True, ""
 
             i = 0
             for state, items in groupby(archive.items, missing_chunk_detector):
                 items = list(items)
                 if state % 2:
                     for chunk_id in items:
-                        report('item metadata chunk missing', chunk_id, i)
+                        report("item metadata chunk missing", chunk_id, i)
                         i += 1
                     continue
                 if state > 0:
@@ -1893,42 +1999,47 @@ class ArchiveChecker:
                             if valid:
                                 yield Item(internal_dict=item)
                             else:
-                                report('Did not get expected metadata dict when unpacking item metadata (%s)' % reason, chunk_id, i)
+                                report(
+                                    "Did not get expected metadata dict when unpacking item metadata (%s)" % reason,
+                                    chunk_id,
+                                    i,
+                                )
                     except IntegrityError as integrity_error:
                         # key.decrypt() detected integrity issues.
                         # maybe the repo gave us a valid cdata, but not for the chunk_id we wanted.
                         # or the authentication of cdata failed, meaning the encrypted data was corrupted.
                         report(str(integrity_error), chunk_id, i)
                     except msgpack.UnpackException:
-                        report('Unpacker crashed while unpacking item metadata, trying to resync...', chunk_id, i)
+                        report("Unpacker crashed while unpacking item metadata, trying to resync...", chunk_id, i)
                         unpacker.resync()
                     except Exception:
-                        report('Exception while decrypting or unpacking item metadata', chunk_id, i)
+                        report("Exception while decrypting or unpacking item metadata", chunk_id, i)
                         raise
                     i += 1
 
-        sort_by = sort_by.split(',')
+        sort_by = sort_by.split(",")
         if any((first, last, glob)):
             archive_infos = self.manifest.archives.list(sort_by=sort_by, glob=glob, first=first, last=last)
             if glob and not archive_infos:
-                logger.warning('--glob-archives %s does not match any archives', glob)
+                logger.warning("--glob-archives %s does not match any archives", glob)
             if first and len(archive_infos) < first:
-                logger.warning('--first %d archives: only found %d archives', first, len(archive_infos))
+                logger.warning("--first %d archives: only found %d archives", first, len(archive_infos))
             if last and len(archive_infos) < last:
-                logger.warning('--last %d archives: only found %d archives', last, len(archive_infos))
+                logger.warning("--last %d archives: only found %d archives", last, len(archive_infos))
         else:
             archive_infos = self.manifest.archives.list(sort_by=sort_by)
         num_archives = len(archive_infos)
 
-        pi = ProgressIndicatorPercent(total=num_archives, msg='Checking archives %3.1f%%', step=0.1,
-                                      msgid='check.rebuild_refcounts')
+        pi = ProgressIndicatorPercent(
+            total=num_archives, msg="Checking archives %3.1f%%", step=0.1, msgid="check.rebuild_refcounts"
+        )
         with cache_if_remote(self.repository) as repository:
             for i, info in enumerate(archive_infos):
                 pi.show(i)
-                logger.info(f'Analyzing archive {info.name} ({i + 1}/{num_archives})')
+                logger.info(f"Analyzing archive {info.name} ({i + 1}/{num_archives})")
                 archive_id = info.id
                 if archive_id not in self.chunks:
-                    logger.error('Archive metadata block %s is missing!', bin_to_hex(archive_id))
+                    logger.error("Archive metadata block %s is missing!", bin_to_hex(archive_id))
                     self.error_found = True
                     del self.manifest.archives[info.name]
                     continue
@@ -1937,17 +2048,17 @@ class ArchiveChecker:
                 try:
                     data = self.key.decrypt(archive_id, cdata)
                 except IntegrityError as integrity_error:
-                    logger.error('Archive metadata block %s is corrupted: %s', bin_to_hex(archive_id), integrity_error)
+                    logger.error("Archive metadata block %s is corrupted: %s", bin_to_hex(archive_id), integrity_error)
                     self.error_found = True
                     del self.manifest.archives[info.name]
                     continue
                 archive = ArchiveItem(internal_dict=msgpack.unpackb(data))
                 if archive.version != 2:
-                    raise Exception('Unknown archive metadata version')
+                    raise Exception("Unknown archive metadata version")
                 items_buffer = ChunkBuffer(self.key)
                 items_buffer.write_chunk = add_callback
                 for item in robust_iterator(archive):
-                    if 'chunks' in item:
+                    if "chunks" in item:
                         verify_file_chunks(info.name, item)
                     items_buffer.add(item)
                 items_buffer.flush(flush=True)
@@ -1966,22 +2077,23 @@ class ArchiveChecker:
             unused = {id_ for id_, entry in self.chunks.iteritems() if entry.refcount == 0}
             orphaned = unused - self.possibly_superseded
             if orphaned:
-                logger.error(f'{len(orphaned)} orphaned objects found!')
+                logger.error(f"{len(orphaned)} orphaned objects found!")
                 self.error_found = True
             if self.repair and unused:
-                logger.info('Deleting %d orphaned and %d superseded objects...' % (
-                    len(orphaned), len(self.possibly_superseded)))
+                logger.info(
+                    "Deleting %d orphaned and %d superseded objects..." % (len(orphaned), len(self.possibly_superseded))
+                )
                 for id_ in unused:
                     self.repository.delete(id_)
-                logger.info('Finished deleting orphaned/superseded objects.')
+                logger.info("Finished deleting orphaned/superseded objects.")
         else:
-            logger.info('Orphaned objects check skipped (needs all archives checked).')
+            logger.info("Orphaned objects check skipped (needs all archives checked).")
 
     def finish(self, save_space=False):
         if self.repair:
-            logger.info('Writing Manifest.')
+            logger.info("Writing Manifest.")
             self.manifest.write()
-            logger.info('Committing repo.')
+            logger.info("Committing repo.")
             self.repository.commit(compact=False, save_space=save_space)
 
 
@@ -1992,13 +2104,29 @@ class ArchiveRecreater:
 
     @staticmethod
     def is_temporary_archive(archive_name):
-        return archive_name.endswith('.recreate')
+        return archive_name.endswith(".recreate")
 
-    def __init__(self, repository, manifest, key, cache, matcher,
-                 exclude_caches=False, exclude_if_present=None, keep_exclude_tags=False,
-                 chunker_params=None, compression=None, recompress=False, always_recompress=False,
-                 dry_run=False, stats=False, progress=False, file_status_printer=None,
-                 timestamp=None, checkpoint_interval=1800):
+    def __init__(
+        self,
+        repository,
+        manifest,
+        key,
+        cache,
+        matcher,
+        exclude_caches=False,
+        exclude_if_present=None,
+        keep_exclude_tags=False,
+        chunker_params=None,
+        compression=None,
+        recompress=False,
+        always_recompress=False,
+        dry_run=False,
+        stats=False,
+        progress=False,
+        file_status_printer=None,
+        timestamp=None,
+        checkpoint_interval=1800,
+    ):
         self.repository = repository
         self.key = key
         self.manifest = manifest
@@ -2011,11 +2139,11 @@ class ArchiveRecreater:
 
         self.rechunkify = chunker_params is not None
         if self.rechunkify:
-            logger.debug('Rechunking archives to %s', chunker_params)
+            logger.debug("Rechunking archives to %s", chunker_params)
         self.chunker_params = chunker_params or CHUNKER_PARAMS
         self.recompress = recompress
         self.always_recompress = always_recompress
-        self.compression = compression or CompressionSpec('none')
+        self.compression = compression or CompressionSpec("none")
         self.seen_chunks = set()
 
         self.timestamp = timestamp
@@ -2043,10 +2171,10 @@ class ArchiveRecreater:
 
         for item in archive.iter_items():
             if not matcher.match(item.path):
-                self.print_file_status('x', item.path)
+                self.print_file_status("x", item.path)
                 continue
             if self.dry_run:
-                self.print_file_status('-', item.path)
+                self.print_file_status("-", item.path)
             else:
                 self.process_item(archive, target, item)
         if self.progress:
@@ -2054,7 +2182,7 @@ class ArchiveRecreater:
 
     def process_item(self, archive, target, item):
         status = file_status(item.mode)
-        if 'chunks' in item:
+        if "chunks" in item:
             self.print_file_status(status, item.path)
             status = None
             self.process_chunks(archive, target, item)
@@ -2103,7 +2231,7 @@ class ArchiveRecreater:
         if self.dry_run:
             return
         if comment is None:
-            comment = archive.metadata.get('comment', '')
+            comment = archive.metadata.get("comment", "")
 
         # Keep for the statistics if necessary
         if self.stats:
@@ -2111,36 +2239,37 @@ class ArchiveRecreater:
 
         if self.timestamp is None:
             additional_metadata = {
-                'time': archive.metadata.time,
-                'time_end': archive.metadata.get('time_end') or archive.metadata.time,
-                'cmdline': archive.metadata.cmdline,
+                "time": archive.metadata.time,
+                "time_end": archive.metadata.get("time_end") or archive.metadata.time,
+                "cmdline": archive.metadata.cmdline,
                 # but also remember recreate metadata:
-                'recreate_cmdline': sys.argv,
+                "recreate_cmdline": sys.argv,
             }
         else:
             additional_metadata = {
-                'cmdline': archive.metadata.cmdline,
+                "cmdline": archive.metadata.cmdline,
                 # but also remember recreate metadata:
-                'recreate_cmdline': sys.argv,
+                "recreate_cmdline": sys.argv,
             }
 
-        target.save(comment=comment, timestamp=self.timestamp,
-                    stats=target.stats, additional_metadata=additional_metadata)
+        target.save(
+            comment=comment, timestamp=self.timestamp, stats=target.stats, additional_metadata=additional_metadata
+        )
         if replace_original:
             archive.delete(Statistics(), progress=self.progress)
             target.rename(archive.name)
         if self.stats:
             target.start = _start
             target.end = datetime.utcnow()
-            log_multi(str(target),
-                      str(target.stats))
+            log_multi(str(target), str(target.stats))
 
     def matcher_add_tagged_dirs(self, archive):
         """Add excludes to the matcher created by exclude_cache and exclude_if_present."""
+
         def exclude(dir, tag_item):
             if self.keep_exclude_tags:
                 tag_files.append(PathPrefixPattern(tag_item.path, recurse_dir=False))
-                tagged_dirs.append(FnmatchPattern(dir + '/', recurse_dir=False))
+                tagged_dirs.append(FnmatchPattern(dir + "/", recurse_dir=False))
             else:
                 tagged_dirs.append(PathPrefixPattern(dir, recurse_dir=False))
 
@@ -2149,7 +2278,8 @@ class ArchiveRecreater:
         tagged_dirs = []
 
         for item in archive.iter_items(
-                filter=lambda item: os.path.basename(item.path) == CACHE_TAG_NAME or matcher.match(item.path)):
+            filter=lambda item: os.path.basename(item.path) == CACHE_TAG_NAME or matcher.match(item.path)
+        ):
             dir, tag_file = os.path.split(item.path)
             if tag_file in self.exclude_if_present:
                 exclude(dir, item)
@@ -2162,27 +2292,41 @@ class ArchiveRecreater:
 
     def create_target(self, archive, target_name=None):
         """Create target archive."""
-        target_name = target_name or archive.name + '.recreate'
+        target_name = target_name or archive.name + ".recreate"
         target = self.create_target_archive(target_name)
         # If the archives use the same chunker params, then don't rechunkify
-        source_chunker_params = tuple(archive.metadata.get('chunker_params', []))
+        source_chunker_params = tuple(archive.metadata.get("chunker_params", []))
         if len(source_chunker_params) == 4 and isinstance(source_chunker_params[0], int):
             # this is a borg < 1.2 chunker_params tuple, no chunker algo specified, but we only had buzhash:
-            source_chunker_params = (CH_BUZHASH, ) + source_chunker_params
+            source_chunker_params = (CH_BUZHASH,) + source_chunker_params
         target.recreate_rechunkify = self.rechunkify and source_chunker_params != target.chunker_params
         if target.recreate_rechunkify:
-            logger.debug('Rechunking archive from %s to %s', source_chunker_params or '(unknown)', target.chunker_params)
+            logger.debug(
+                "Rechunking archive from %s to %s", source_chunker_params or "(unknown)", target.chunker_params
+            )
         target.process_file_chunks = ChunksProcessor(
-            cache=self.cache, key=self.key,
-            add_item=target.add_item, write_checkpoint=target.write_checkpoint,
-            checkpoint_interval=self.checkpoint_interval, rechunkify=target.recreate_rechunkify).process_file_chunks
+            cache=self.cache,
+            key=self.key,
+            add_item=target.add_item,
+            write_checkpoint=target.write_checkpoint,
+            checkpoint_interval=self.checkpoint_interval,
+            rechunkify=target.recreate_rechunkify,
+        ).process_file_chunks
         target.chunker = get_chunker(*target.chunker_params, seed=self.key.chunk_seed)
         return target
 
     def create_target_archive(self, name):
-        target = Archive(self.repository, self.key, self.manifest, name, create=True,
-                          progress=self.progress, chunker_params=self.chunker_params, cache=self.cache,
-                          checkpoint_interval=self.checkpoint_interval)
+        target = Archive(
+            self.repository,
+            self.key,
+            self.manifest,
+            name,
+            create=True,
+            progress=self.progress,
+            chunker_params=self.chunker_params,
+            cache=self.cache,
+            checkpoint_interval=self.checkpoint_interval,
+        )
         return target
 
     def open_archive(self, name, **kwargs):
diff --git a/src/borg/archiver.py b/src/borg/archiver.py
index c4831b875..ced4ce037 100644
--- a/src/borg/archiver.py
+++ b/src/borg/archiver.py
@@ -82,7 +82,12 @@ try:
     from .helpers import iter_separated
     from .helpers import get_tar_filter
     from .nanorst import rst_to_terminal
-    from .patterns import ArgparsePatternAction, ArgparseExcludeFileAction, ArgparsePatternFileAction, parse_exclude_pattern
+    from .patterns import (
+        ArgparsePatternAction,
+        ArgparseExcludeFileAction,
+        ArgparsePatternFileAction,
+        parse_exclude_pattern,
+    )
     from .patterns import PatternMatcher
     from .item import Item
     from .platform import get_flags, get_process_id, SyncFile
@@ -114,17 +119,30 @@ def argument(args, str_or_bool):
     return str_or_bool
 
 
-def get_repository(location, *, create, exclusive, lock_wait, lock, append_only,
-                   make_parent_dirs, storage_quota, args):
-    if location.proto == 'ssh':
-        repository = RemoteRepository(location, create=create, exclusive=exclusive,
-                                      lock_wait=lock_wait, lock=lock, append_only=append_only,
-                                      make_parent_dirs=make_parent_dirs, args=args)
+def get_repository(location, *, create, exclusive, lock_wait, lock, append_only, make_parent_dirs, storage_quota, args):
+    if location.proto == "ssh":
+        repository = RemoteRepository(
+            location,
+            create=create,
+            exclusive=exclusive,
+            lock_wait=lock_wait,
+            lock=lock,
+            append_only=append_only,
+            make_parent_dirs=make_parent_dirs,
+            args=args,
+        )
 
     else:
-        repository = Repository(location.path, create=create, exclusive=exclusive,
-                                lock_wait=lock_wait, lock=lock, append_only=append_only,
-                                make_parent_dirs=make_parent_dirs, storage_quota=storage_quota)
+        repository = Repository(
+            location.path,
+            create=create,
+            exclusive=exclusive,
+            lock_wait=lock_wait,
+            lock=lock,
+            append_only=append_only,
+            make_parent_dirs=make_parent_dirs,
+            storage_quota=storage_quota,
+        )
     return repository
 
 
@@ -136,16 +154,25 @@ def compat_check(*, create, manifest, key, cache, compatibility, decorator_name)
             raise AssertionError(f"{decorator_name} decorator compatibility argument must be of type tuple")
     else:
         if compatibility is not None:
-            raise AssertionError(f"{decorator_name} called with compatibility argument, "
-                                 f"but would not check {compatibility!r}")
+            raise AssertionError(
+                f"{decorator_name} called with compatibility argument, " f"but would not check {compatibility!r}"
+            )
         if create:
             compatibility = Manifest.NO_OPERATION_CHECK
     return compatibility
 
 
-def with_repository(fake=False, invert_fake=False, create=False, lock=True,
-                    exclusive=False, manifest=True, cache=False, secure=True,
-                    compatibility=None):
+def with_repository(
+    fake=False,
+    invert_fake=False,
+    create=False,
+    lock=True,
+    exclusive=False,
+    manifest=True,
+    cache=False,
+    secure=True,
+    compatibility=None,
+):
     """
     Method decorator for subcommand-handling methods: do_XYZ(self, args, repository, …)
 
@@ -160,8 +187,14 @@ def with_repository(fake=False, invert_fake=False, create=False, lock=True,
     :param compatibility: mandatory if not create and (manifest or cache), specifies mandatory feature categories to check
     """
     # Note: with_repository decorator does not have a "key" argument (yet?)
-    compatibility = compat_check(create=create, manifest=manifest, key=manifest, cache=cache,
-                                 compatibility=compatibility, decorator_name='with_repository')
+    compatibility = compat_check(
+        create=create,
+        manifest=manifest,
+        key=manifest,
+        cache=cache,
+        compatibility=compatibility,
+        decorator_name="with_repository",
+    )
 
     # To process the `--bypass-lock` option if specified, we need to
     # modify `lock` inside `wrapper`. Therefore we cannot use the
@@ -175,41 +208,57 @@ def with_repository(fake=False, invert_fake=False, create=False, lock=True,
     def decorator(method):
         @functools.wraps(method)
         def wrapper(self, args, **kwargs):
-            location = getattr(args, 'location')
+            location = getattr(args, "location")
             if not location.valid:  # location always must be given
-                raise Error('missing repository, please use --repo or BORG_REPO env var!')
-            lock = getattr(args, 'lock', _lock)
-            append_only = getattr(args, 'append_only', False)
-            storage_quota = getattr(args, 'storage_quota', None)
-            make_parent_dirs = getattr(args, 'make_parent_dirs', False)
+                raise Error("missing repository, please use --repo or BORG_REPO env var!")
+            lock = getattr(args, "lock", _lock)
+            append_only = getattr(args, "append_only", False)
+            storage_quota = getattr(args, "storage_quota", None)
+            make_parent_dirs = getattr(args, "make_parent_dirs", False)
             if argument(args, fake) ^ invert_fake:
                 return method(self, args, repository=None, **kwargs)
 
-            repository = get_repository(location, create=create, exclusive=argument(args, exclusive),
-                                        lock_wait=self.lock_wait, lock=lock, append_only=append_only,
-                                        make_parent_dirs=make_parent_dirs, storage_quota=storage_quota,
-                                        args=args)
+            repository = get_repository(
+                location,
+                create=create,
+                exclusive=argument(args, exclusive),
+                lock_wait=self.lock_wait,
+                lock=lock,
+                append_only=append_only,
+                make_parent_dirs=make_parent_dirs,
+                storage_quota=storage_quota,
+                args=args,
+            )
 
             with repository:
-                if repository.version not in (2, ):
-                    raise Error("This borg version only accepts version 2 repos for -r/--repo. "
-                                "You can use 'borg transfer' to copy archives from old to new repos.")
+                if repository.version not in (2,):
+                    raise Error(
+                        "This borg version only accepts version 2 repos for -r/--repo. "
+                        "You can use 'borg transfer' to copy archives from old to new repos."
+                    )
                 if manifest or cache:
-                    kwargs['manifest'], kwargs['key'] = Manifest.load(repository, compatibility)
-                    if 'compression' in args:
-                        kwargs['key'].compressor = args.compression.compressor
+                    kwargs["manifest"], kwargs["key"] = Manifest.load(repository, compatibility)
+                    if "compression" in args:
+                        kwargs["key"].compressor = args.compression.compressor
                     if secure:
-                        assert_secure(repository, kwargs['manifest'], self.lock_wait)
+                        assert_secure(repository, kwargs["manifest"], self.lock_wait)
                 if cache:
-                    with Cache(repository, kwargs['key'], kwargs['manifest'],
-                               progress=getattr(args, 'progress', False), lock_wait=self.lock_wait,
-                               cache_mode=getattr(args, 'files_cache_mode', FILES_CACHE_MODE_DISABLED),
-                               consider_part_files=getattr(args, 'consider_part_files', False),
-                               iec=getattr(args, 'iec', False)) as cache_:
+                    with Cache(
+                        repository,
+                        kwargs["key"],
+                        kwargs["manifest"],
+                        progress=getattr(args, "progress", False),
+                        lock_wait=self.lock_wait,
+                        cache_mode=getattr(args, "files_cache_mode", FILES_CACHE_MODE_DISABLED),
+                        consider_part_files=getattr(args, "consider_part_files", False),
+                        iec=getattr(args, "iec", False),
+                    ) as cache_:
                         return method(self, args, repository=repository, cache=cache_, **kwargs)
                 else:
                     return method(self, args, repository=repository, **kwargs)
+
         return wrapper
+
     return decorator
 
 
@@ -220,66 +269,94 @@ def with_other_repository(manifest=False, key=False, cache=False, compatibility=
     the repository at the "other location" is intended to get used as a **source** (== read operations).
     """
 
-    compatibility = compat_check(create=False, manifest=manifest, key=key, cache=cache,
-                                 compatibility=compatibility, decorator_name='with_other_repository')
+    compatibility = compat_check(
+        create=False,
+        manifest=manifest,
+        key=key,
+        cache=cache,
+        compatibility=compatibility,
+        decorator_name="with_other_repository",
+    )
 
     def decorator(method):
         @functools.wraps(method)
         def wrapper(self, args, **kwargs):
-            location = getattr(args, 'other_location')
+            location = getattr(args, "other_location")
             if not location.valid:  # nothing to do
                 return method(self, args, **kwargs)
 
-            repository = get_repository(location, create=False, exclusive=True,
-                                        lock_wait=self.lock_wait, lock=True, append_only=False,
-                                        make_parent_dirs=False, storage_quota=None,
-                                        args=args)
+            repository = get_repository(
+                location,
+                create=False,
+                exclusive=True,
+                lock_wait=self.lock_wait,
+                lock=True,
+                append_only=False,
+                make_parent_dirs=False,
+                storage_quota=None,
+                args=args,
+            )
 
             with repository:
-                if repository.version not in (1, 2, ):
+                if repository.version not in (1, 2):
                     raise Error("This borg version only accepts version 1 or 2 repos for --other-repo.")
-                kwargs['other_repository'] = repository
+                kwargs["other_repository"] = repository
                 if manifest or key or cache:
                     manifest_, key_ = Manifest.load(repository, compatibility)
                     assert_secure(repository, manifest_, self.lock_wait)
                     if manifest:
-                        kwargs['other_manifest'] = manifest_
+                        kwargs["other_manifest"] = manifest_
                     if key:
-                        kwargs['other_key'] = key_
+                        kwargs["other_key"] = key_
                 if cache:
-                    with Cache(repository, key_, manifest_,
-                               progress=False, lock_wait=self.lock_wait,
-                               cache_mode=getattr(args, 'files_cache_mode', FILES_CACHE_MODE_DISABLED),
-                               consider_part_files=getattr(args, 'consider_part_files', False),
-                               iec=getattr(args, 'iec', False)) as cache_:
-                        kwargs['other_cache'] = cache_
+                    with Cache(
+                        repository,
+                        key_,
+                        manifest_,
+                        progress=False,
+                        lock_wait=self.lock_wait,
+                        cache_mode=getattr(args, "files_cache_mode", FILES_CACHE_MODE_DISABLED),
+                        consider_part_files=getattr(args, "consider_part_files", False),
+                        iec=getattr(args, "iec", False),
+                    ) as cache_:
+                        kwargs["other_cache"] = cache_
                         return method(self, args, **kwargs)
                 else:
                     return method(self, args, **kwargs)
+
         return wrapper
+
     return decorator
 
 
 def with_archive(method):
     @functools.wraps(method)
     def wrapper(self, args, repository, key, manifest, **kwargs):
-        archive_name = getattr(args, 'name', None)
+        archive_name = getattr(args, "name", None)
         assert archive_name is not None
-        archive = Archive(repository, key, manifest, archive_name,
-                          numeric_ids=getattr(args, 'numeric_ids', False),
-                          noflags=getattr(args, 'nobsdflags', False) or getattr(args, 'noflags', False),
-                          noacls=getattr(args, 'noacls', False),
-                          noxattrs=getattr(args, 'noxattrs', False),
-                          cache=kwargs.get('cache'),
-                          consider_part_files=args.consider_part_files, log_json=args.log_json, iec=args.iec)
+        archive = Archive(
+            repository,
+            key,
+            manifest,
+            archive_name,
+            numeric_ids=getattr(args, "numeric_ids", False),
+            noflags=getattr(args, "nobsdflags", False) or getattr(args, "noflags", False),
+            noacls=getattr(args, "noacls", False),
+            noxattrs=getattr(args, "noxattrs", False),
+            cache=kwargs.get("cache"),
+            consider_part_files=args.consider_part_files,
+            log_json=args.log_json,
+            iec=args.iec,
+        )
         return method(self, args, repository=repository, manifest=manifest, key=key, archive=archive, **kwargs)
+
     return wrapper
 
 
 def parse_storage_quota(storage_quota):
     parsed = parse_file_size(storage_quota)
-    if parsed < parse_file_size('10M'):
-        raise argparse.ArgumentTypeError('quota is too small (%s). At least 10M are required.' % storage_quota)
+    if parsed < parse_file_size("10M"):
+        raise argparse.ArgumentTypeError("quota is too small (%s). At least 10M are required." % storage_quota)
     return parsed
 
 
@@ -288,23 +365,23 @@ def get_func(args):
     # func is used at the leaf parsers of the argparse parser tree,
     # fallback_func at next level towards the root,
     # fallback2_func at the 2nd next level (which is root in our case).
-    for name in 'func', 'fallback_func', 'fallback2_func':
+    for name in "func", "fallback_func", "fallback2_func":
         func = getattr(args, name, None)
         if func is not None:
             return func
-    raise Exception('expected func attributes not found')
+    raise Exception("expected func attributes not found")
 
 
 class Highlander(argparse.Action):
     """make sure some option is only given once"""
+
     def __call__(self, parser, namespace, values, option_string=None):
         if getattr(namespace, self.dest, None) != self.default:
-            raise argparse.ArgumentError(self, 'There can be only one.')
+            raise argparse.ArgumentError(self, "There can be only one.")
         setattr(namespace, self.dest, values)
 
 
 class Archiver:
-
     def __init__(self, lock_wait=None, prog=None):
         self.exit_code = EXIT_SUCCESS
         self.lock_wait = lock_wait
@@ -324,13 +401,12 @@ class Archiver:
         # if we get called with status == None, the final file status was already printed
         if self.output_list and status is not None and (self.output_filter is None or status in self.output_filter):
             if self.log_json:
-                print(json.dumps({
-                    'type': 'file_status',
-                    'status': status,
-                    'path': remove_surrogates(path),
-                }), file=sys.stderr)
+                print(
+                    json.dumps({"type": "file_status", "status": status, "path": remove_surrogates(path)}),
+                    file=sys.stderr,
+                )
             else:
-                logging.getLogger('borg.output.list').info("%1s %s", status, remove_surrogates(path))
+                logging.getLogger("borg.output.list").info("%1s %s", status, remove_surrogates(path))
 
     @staticmethod
     def build_matcher(inclexcl_patterns, include_paths):
@@ -351,9 +427,9 @@ class Archiver:
 
     @with_other_repository(manifest=True, key=True, compatibility=(Manifest.Operation.READ,))
     @with_repository(exclusive=True, manifest=True, cache=True, compatibility=(Manifest.Operation.WRITE,))
-    def do_transfer(self, args, *,
-               repository, manifest, key, cache,
-               other_repository=None, other_manifest=None, other_key=None):
+    def do_transfer(
+        self, args, *, repository, manifest, key, cache, other_repository=None, other_manifest=None, other_key=None
+    ):
         """archives transfer from other repository, optionally upgrade data format"""
         dry_run = args.dry_run
         args.consider_checkpoints = True
@@ -362,10 +438,11 @@ class Archiver:
             return EXIT_SUCCESS
 
         from . import upgrade as upgrade_mod
+
         try:
-            UpgraderCls = getattr(upgrade_mod, f'Upgrader{args.upgrader}')
+            UpgraderCls = getattr(upgrade_mod, f"Upgrader{args.upgrader}")
         except AttributeError:
-            self.print_error(f'No such upgrader: {args.upgrader}')
+            self.print_error(f"No such upgrader: {args.upgrader}")
             return EXIT_ERROR
 
         upgrader = UpgraderCls(cache=cache)
@@ -382,7 +459,7 @@ class Archiver:
                 archive = Archive(repository, key, manifest, name, cache=cache, create=True) if not dry_run else None
                 upgrader.new_archive(archive=archive)
                 for item in other_archive.iter_items():
-                    if 'chunks' in item:
+                    if "chunks" in item:
                         chunks = []
                         for chunk_id, size in item.chunks:
                             refcount = cache.seen_chunk(chunk_id, size)
@@ -392,8 +469,9 @@ class Archiver:
                                     # keep compressed payload same, avoid decompression / recompression
                                     data = other_key.decrypt(chunk_id, cdata, decompress=False)
                                     data = upgrader.upgrade_compressed_chunk(chunk=data)
-                                    chunk_entry = cache.add_chunk(chunk_id, data, archive.stats, wait=False,
-                                                                  compress=False, size=size)
+                                    chunk_entry = cache.add_chunk(
+                                        chunk_id, data, archive.stats, wait=False, compress=False, size=size
+                                    )
                                     cache.repository.async_response(wait=False)
                                     chunks.append(chunk_entry)
                                 transfer_size += size
@@ -410,18 +488,23 @@ class Archiver:
                 if not dry_run:
                     additional_metadata = upgrader.upgrade_archive_metadata(metadata=other_archive.metadata)
                     archive.save(stats=archive.stats, additional_metadata=additional_metadata)
-                    print(f"{name}: finished. "
-                          f"transfer_size: {format_file_size(transfer_size)} "
-                          f"present_size: {format_file_size(present_size)}")
+                    print(
+                        f"{name}: finished. "
+                        f"transfer_size: {format_file_size(transfer_size)} "
+                        f"present_size: {format_file_size(present_size)}"
+                    )
                 else:
-                    print(f"{name}: completed" if transfer_size == 0 else
-                          f"{name}: incomplete, "
-                          f"transfer_size: {format_file_size(transfer_size)} "
-                          f"present_size: {format_file_size(present_size)}")
+                    print(
+                        f"{name}: completed"
+                        if transfer_size == 0
+                        else f"{name}: incomplete, "
+                        f"transfer_size: {format_file_size(transfer_size)} "
+                        f"present_size: {format_file_size(present_size)}"
+                    )
         return EXIT_SUCCESS
 
     @with_repository(create=True, exclusive=True, manifest=False)
-    @with_other_repository(key=True, compatibility=(Manifest.Operation.READ, ))
+    @with_other_repository(key=True, compatibility=(Manifest.Operation.READ,))
     def do_rcreate(self, args, repository, *, other_repository=None, other_key=None):
         """Create a new, empty repository"""
         path = args.location.canonical_path()
@@ -439,34 +522,42 @@ class Archiver:
             pass
         if key.tam_required:
             tam_file = tam_required_file(repository)
-            open(tam_file, 'w').close()
+            open(tam_file, "w").close()
 
-        if key.NAME != 'plaintext':
+        if key.NAME != "plaintext":
             logger.warning(
-                '\n'
-                'IMPORTANT: you will need both KEY AND PASSPHRASE to access this repo!\n'
-                'If you used a repokey mode, the key is stored in the repo, but you should back it up separately.\n'
+                "\n"
+                "IMPORTANT: you will need both KEY AND PASSPHRASE to access this repo!\n"
+                "If you used a repokey mode, the key is stored in the repo, but you should back it up separately.\n"
                 'Use "borg key export" to export the key, optionally in printable format.\n'
-                'Write down the passphrase. Store both at safe place(s).\n')
+                "Write down the passphrase. Store both at safe place(s).\n"
+            )
         return self.exit_code
 
     @with_repository(exclusive=True, manifest=False)
     def do_check(self, args, repository):
         """Check repository consistency"""
         if args.repair:
-            msg = ("This is a potentially dangerous function.\n"
-                   "check --repair might lead to data loss (for kinds of corruption it is not\n"
-                   "capable of dealing with). BE VERY CAREFUL!\n"
-                   "\n"
-                   "Type 'YES' if you understand this and want to continue: ")
-            if not yes(msg, false_msg="Aborting.", invalid_msg="Invalid answer, aborting.",
-                       truish=('YES', ), retry=False,
-                       env_var_override='BORG_CHECK_I_KNOW_WHAT_I_AM_DOING'):
+            msg = (
+                "This is a potentially dangerous function.\n"
+                "check --repair might lead to data loss (for kinds of corruption it is not\n"
+                "capable of dealing with). BE VERY CAREFUL!\n"
+                "\n"
+                "Type 'YES' if you understand this and want to continue: "
+            )
+            if not yes(
+                msg,
+                false_msg="Aborting.",
+                invalid_msg="Invalid answer, aborting.",
+                truish=("YES",),
+                retry=False,
+                env_var_override="BORG_CHECK_I_KNOW_WHAT_I_AM_DOING",
+            ):
                 return EXIT_ERROR
-        if args.repo_only and any(
-           (args.verify_data, args.first, args.last, args.glob_archives)):
-            self.print_error("--repository-only contradicts --first, --last, -a / --glob-archives "
-                             " and --verify-data arguments.")
+        if args.repo_only and any((args.verify_data, args.first, args.last, args.glob_archives)):
+            self.print_error(
+                "--repository-only contradicts --first, --last, -a / --glob-archives " " and --verify-data arguments."
+            )
             return EXIT_ERROR
         if args.repair and args.max_duration:
             self.print_error("--repair does not allow --max-duration argument.")
@@ -481,33 +572,40 @@ class Archiver:
         if not args.archives_only:
             if not repository.check(repair=args.repair, save_space=args.save_space, max_duration=args.max_duration):
                 return EXIT_WARNING
-        if not args.repo_only and not ArchiveChecker().check(repository, repair=args.repair,
-                first=args.first, last=args.last, sort_by=args.sort_by or 'ts', glob=args.glob_archives,
-                verify_data=args.verify_data, save_space=args.save_space):
+        if not args.repo_only and not ArchiveChecker().check(
+            repository,
+            repair=args.repair,
+            first=args.first,
+            last=args.last,
+            sort_by=args.sort_by or "ts",
+            glob=args.glob_archives,
+            verify_data=args.verify_data,
+            save_space=args.save_space,
+        ):
             return EXIT_WARNING
         return EXIT_SUCCESS
 
     @with_repository(compatibility=(Manifest.Operation.CHECK,))
     def do_change_passphrase(self, args, repository, manifest, key):
         """Change repository key file passphrase"""
-        if not hasattr(key, 'change_passphrase'):
-            print('This repository is not encrypted, cannot change the passphrase.')
+        if not hasattr(key, "change_passphrase"):
+            print("This repository is not encrypted, cannot change the passphrase.")
             return EXIT_ERROR
         key.change_passphrase()
-        logger.info('Key updated')
-        if hasattr(key, 'find_key'):
+        logger.info("Key updated")
+        if hasattr(key, "find_key"):
             # print key location to make backing it up easier
-            logger.info('Key location: %s', key.find_key())
+            logger.info("Key location: %s", key.find_key())
         return EXIT_SUCCESS
 
     @with_repository(exclusive=True, manifest=True, cache=True, compatibility=(Manifest.Operation.CHECK,))
     def do_change_location(self, args, repository, manifest, key, cache):
         """Change repository key location"""
-        if not hasattr(key, 'change_passphrase'):
-            print('This repository is not encrypted, cannot change the key location.')
+        if not hasattr(key, "change_passphrase"):
+            print("This repository is not encrypted, cannot change the key location.")
             return EXIT_ERROR
 
-        if args.key_mode == 'keyfile':
+        if args.key_mode == "keyfile":
             if isinstance(key, AESOCBRepoKey):
                 key_new = AESOCBKeyfileKey(repository)
             elif isinstance(key, CHPORepoKey):
@@ -519,7 +617,7 @@ class Archiver:
             else:
                 print("Change not needed or not supported.")
                 return EXIT_WARNING
-        if args.key_mode == 'repokey':
+        if args.key_mode == "repokey":
             if isinstance(key, AESOCBKeyfileKey):
                 key_new = AESOCBRepoKey(repository)
             elif isinstance(key, CHPOKeyfileKey):
@@ -532,8 +630,16 @@ class Archiver:
                 print("Change not needed or not supported.")
                 return EXIT_WARNING
 
-        for name in ('repository_id', 'enc_key', 'enc_hmac_key', 'id_key', 'chunk_seed',
-                     'tam_required', 'sessionid', 'cipher'):
+        for name in (
+            "repository_id",
+            "enc_key",
+            "enc_hmac_key",
+            "id_key",
+            "chunk_seed",
+            "tam_required",
+            "sessionid",
+            "cipher",
+        ):
             value = getattr(key, name)
             setattr(key_new, name, value)
 
@@ -552,20 +658,20 @@ class Archiver:
         cache.key = key_new
         cache.commit()
 
-        loc = key_new.find_key() if hasattr(key_new, 'find_key') else None
+        loc = key_new.find_key() if hasattr(key_new, "find_key") else None
         if args.keep:
-            logger.info(f'Key copied to {loc}')
+            logger.info(f"Key copied to {loc}")
         else:
             key.remove(key.target)  # remove key from current location
-            logger.info(f'Key moved to {loc}')
+            logger.info(f"Key moved to {loc}")
 
         return EXIT_SUCCESS
 
     @with_repository(exclusive=True, compatibility=(Manifest.Operation.CHECK,))
     def do_change_algorithm(self, args, repository, manifest, key):
         """Change repository key algorithm"""
-        if not hasattr(key, 'change_passphrase'):
-            print('This repository is not encrypted, cannot change the algorithm.')
+        if not hasattr(key, "change_passphrase"):
+            print("This repository is not encrypted, cannot change the algorithm.")
             return EXIT_ERROR
         key.save(key.target, key._passphrase, algorithm=KEY_ALGORITHMS[args.algorithm])
         return EXIT_SUCCESS
@@ -601,7 +707,7 @@ class Archiver:
             if not args.path:
                 self.print_error("input file to import key from expected")
                 return EXIT_ERROR
-            if args.path != '-' and not os.path.exists(args.path):
+            if args.path != "-" and not os.path.exists(args.path):
                 self.print_error("input file does not exist: " + args.path)
                 return EXIT_ERROR
             manager.import_keyfile(args)
@@ -609,38 +715,43 @@ class Archiver:
 
     def do_benchmark_crud(self, args):
         """Benchmark Create, Read, Update, Delete for archives."""
+
         def measurement_run(repo, path):
-            compression = '--compression=none'
+            compression = "--compression=none"
             # measure create perf (without files cache to always have it chunking)
             t_start = time.monotonic()
-            rc = self.do_create(self.parse_args([f'--repo={repo}', 'create', compression, '--files-cache=disabled',
-                                                 'borg-benchmark-crud1', path]))
+            rc = self.do_create(
+                self.parse_args(
+                    [f"--repo={repo}", "create", compression, "--files-cache=disabled", "borg-benchmark-crud1", path]
+                )
+            )
             t_end = time.monotonic()
             dt_create = t_end - t_start
             assert rc == 0
             # now build files cache
-            rc1 = self.do_create(self.parse_args([f'--repo={repo}', 'create', compression,
-                                                  'borg-benchmark-crud2', path]))
-            rc2 = self.do_delete(self.parse_args([f'--repo={repo}', 'delete', '-a', 'borg-benchmark-crud2']))
+            rc1 = self.do_create(
+                self.parse_args([f"--repo={repo}", "create", compression, "borg-benchmark-crud2", path])
+            )
+            rc2 = self.do_delete(self.parse_args([f"--repo={repo}", "delete", "-a", "borg-benchmark-crud2"]))
             assert rc1 == rc2 == 0
             # measure a no-change update (archive1 is still present)
             t_start = time.monotonic()
-            rc1 = self.do_create(self.parse_args([f'--repo={repo}', 'create', compression,
-                                                  'borg-benchmark-crud3', path]))
+            rc1 = self.do_create(
+                self.parse_args([f"--repo={repo}", "create", compression, "borg-benchmark-crud3", path])
+            )
             t_end = time.monotonic()
             dt_update = t_end - t_start
-            rc2 = self.do_delete(self.parse_args([f'--repo={repo}', 'delete', '-a', 'borg-benchmark-crud3']))
+            rc2 = self.do_delete(self.parse_args([f"--repo={repo}", "delete", "-a", "borg-benchmark-crud3"]))
             assert rc1 == rc2 == 0
             # measure extraction (dry-run: without writing result to disk)
             t_start = time.monotonic()
-            rc = self.do_extract(self.parse_args([f'--repo={repo}', 'extract', 'borg-benchmark-crud1',
-                                                  '--dry-run']))
+            rc = self.do_extract(self.parse_args([f"--repo={repo}", "extract", "borg-benchmark-crud1", "--dry-run"]))
             t_end = time.monotonic()
             dt_extract = t_end - t_start
             assert rc == 0
             # measure archive deletion (of LAST present archive with the data)
             t_start = time.monotonic()
-            rc = self.do_delete(self.parse_args([f'--repo={repo}', 'delete', '-a', 'borg-benchmark-crud1']))
+            rc = self.do_delete(self.parse_args([f"--repo={repo}", "delete", "-a", "borg-benchmark-crud1"]))
             t_end = time.monotonic()
             dt_delete = t_end - t_start
             assert rc == 0
@@ -649,11 +760,11 @@ class Archiver:
         @contextmanager
         def test_files(path, count, size, random):
             try:
-                path = os.path.join(path, 'borg-test-data')
+                path = os.path.join(path, "borg-test-data")
                 os.makedirs(path)
-                z_buff = None if random else memoryview(zeros)[:size] if size <= len(zeros) else b'\0' * size
+                z_buff = None if random else memoryview(zeros)[:size] if size <= len(zeros) else b"\0" * size
                 for i in range(count):
-                    fname = os.path.join(path, 'file_%d' % i)
+                    fname = os.path.join(path, "file_%d" % i)
                     data = z_buff if not random else os.urandom(size)
                     with SyncFile(fname, binary=True) as fd:  # used for posix_fadvise's sake
                         fd.write(data)
@@ -661,19 +772,16 @@ class Archiver:
             finally:
                 shutil.rmtree(path)
 
-        if '_BORG_BENCHMARK_CRUD_TEST' in os.environ:
-            tests = [
-                ('Z-TEST', 1, 1, False),
-                ('R-TEST', 1, 1, True),
-            ]
+        if "_BORG_BENCHMARK_CRUD_TEST" in os.environ:
+            tests = [("Z-TEST", 1, 1, False), ("R-TEST", 1, 1, True)]
         else:
             tests = [
-                ('Z-BIG', 10, 100000000, False),
-                ('R-BIG', 10, 100000000, True),
-                ('Z-MEDIUM', 1000, 1000000, False),
-                ('R-MEDIUM', 1000, 1000000, True),
-                ('Z-SMALL', 10000, 10000, False),
-                ('R-SMALL', 10000, 10000, True),
+                ("Z-BIG", 10, 100000000, False),
+                ("R-BIG", 10, 100000000, True),
+                ("Z-MEDIUM", 1000, 1000000, False),
+                ("R-MEDIUM", 1000, 1000000, True),
+                ("Z-SMALL", 10000, 10000, False),
+                ("R-SMALL", 10000, 10000, True),
             ]
 
         for msg, count, size, random in tests:
@@ -681,25 +789,27 @@ class Archiver:
                 dt_create, dt_update, dt_extract, dt_delete = measurement_run(args.location.canonical_path(), path)
             total_size_MB = count * size / 1e06
             file_size_formatted = format_file_size(size)
-            content = 'random' if random else 'all-zero'
-            fmt = '%s-%-10s %9.2f MB/s (%d * %s %s files: %.2fs)'
-            print(fmt % ('C', msg, total_size_MB / dt_create, count, file_size_formatted, content, dt_create))
-            print(fmt % ('R', msg, total_size_MB / dt_extract, count, file_size_formatted, content, dt_extract))
-            print(fmt % ('U', msg, total_size_MB / dt_update, count, file_size_formatted, content, dt_update))
-            print(fmt % ('D', msg, total_size_MB / dt_delete, count, file_size_formatted, content, dt_delete))
+            content = "random" if random else "all-zero"
+            fmt = "%s-%-10s %9.2f MB/s (%d * %s %s files: %.2fs)"
+            print(fmt % ("C", msg, total_size_MB / dt_create, count, file_size_formatted, content, dt_create))
+            print(fmt % ("R", msg, total_size_MB / dt_extract, count, file_size_formatted, content, dt_extract))
+            print(fmt % ("U", msg, total_size_MB / dt_update, count, file_size_formatted, content, dt_update))
+            print(fmt % ("D", msg, total_size_MB / dt_delete, count, file_size_formatted, content, dt_delete))
 
         return 0
 
     def do_benchmark_cpu(self, args):
         """Benchmark CPU bound operations."""
         from timeit import timeit
-        random_10M = os.urandom(10*1000*1000)
+
+        random_10M = os.urandom(10 * 1000 * 1000)
         key_256 = os.urandom(32)
         key_128 = os.urandom(16)
         key_96 = os.urandom(12)
 
         import io
         from .chunker import get_chunker
+
         print("Chunkers =======================================================")
         size = "1GB"
 
@@ -716,16 +826,15 @@ class Archiver:
             print(f"{spec:<24} {size:<10} {timeit(func, number=100):.3f}s")
 
         from .checksums import crc32, xxh64
+
         print("Non-cryptographic checksums / hashes ===========================")
         size = "1GB"
-        tests = [
-            ("xxh64", lambda: xxh64(random_10M)),
-            ("crc32 (zlib)", lambda: crc32(random_10M)),
-        ]
+        tests = [("xxh64", lambda: xxh64(random_10M)), ("crc32 (zlib)", lambda: crc32(random_10M))]
         for spec, func in tests:
             print(f"{spec:<24} {size:<10} {timeit(func, number=100):.3f}s")
 
         from .crypto.low_level import hmac_sha256, blake2b_256
+
         print("Cryptographic hashes / MACs ====================================")
         size = "1GB"
         for spec, func in [
@@ -736,18 +845,33 @@ class Archiver:
 
         from .crypto.low_level import AES256_CTR_BLAKE2b, AES256_CTR_HMAC_SHA256
         from .crypto.low_level import AES256_OCB, CHACHA20_POLY1305
+
         print("Encryption =====================================================")
         size = "1GB"
 
         tests = [
-            ("aes-256-ctr-hmac-sha256", lambda: AES256_CTR_HMAC_SHA256(
-                key_256, key_256, iv=key_128, header_len=1, aad_offset=1).encrypt(random_10M, header=b'X')),
-            ("aes-256-ctr-blake2b", lambda: AES256_CTR_BLAKE2b(
-                key_256*4, key_256, iv=key_128, header_len=1, aad_offset=1).encrypt(random_10M, header=b'X')),
-            ("aes-256-ocb", lambda: AES256_OCB(
-                key_256, iv=key_96, header_len=1, aad_offset=1).encrypt(random_10M, header=b'X')),
-            ("chacha20-poly1305", lambda: CHACHA20_POLY1305(
-                key_256, iv=key_96, header_len=1, aad_offset=1).encrypt(random_10M, header=b'X')),
+            (
+                "aes-256-ctr-hmac-sha256",
+                lambda: AES256_CTR_HMAC_SHA256(key_256, key_256, iv=key_128, header_len=1, aad_offset=1).encrypt(
+                    random_10M, header=b"X"
+                ),
+            ),
+            (
+                "aes-256-ctr-blake2b",
+                lambda: AES256_CTR_BLAKE2b(key_256 * 4, key_256, iv=key_128, header_len=1, aad_offset=1).encrypt(
+                    random_10M, header=b"X"
+                ),
+            ),
+            (
+                "aes-256-ocb",
+                lambda: AES256_OCB(key_256, iv=key_96, header_len=1, aad_offset=1).encrypt(random_10M, header=b"X"),
+            ),
+            (
+                "chacha20-poly1305",
+                lambda: CHACHA20_POLY1305(key_256, iv=key_96, header_len=1, aad_offset=1).encrypt(
+                    random_10M, header=b"X"
+                ),
+            ),
         ]
         for spec, func in tests:
             print(f"{spec:<24} {size:<10} {timeit(func, number=100):.3f}s")
@@ -755,27 +879,28 @@ class Archiver:
         print("KDFs (slow is GOOD, use argon2!) ===============================")
         count = 5
         for spec, func in [
-            ("pbkdf2", lambda: FlexiKey.pbkdf2('mypassphrase', b'salt'*8, PBKDF2_ITERATIONS, 32)),
-            ("argon2", lambda: FlexiKey.argon2('mypassphrase', 64, b'S' * ARGON2_SALT_BYTES, **ARGON2_ARGS)),
+            ("pbkdf2", lambda: FlexiKey.pbkdf2("mypassphrase", b"salt" * 8, PBKDF2_ITERATIONS, 32)),
+            ("argon2", lambda: FlexiKey.argon2("mypassphrase", 64, b"S" * ARGON2_SALT_BYTES, **ARGON2_ARGS)),
         ]:
             print(f"{spec:<24} {count:<10} {timeit(func, number=count):.3f}s")
 
         from .compress import CompressionSpec
+
         print("Compression ====================================================")
         for spec in [
-            'lz4',
-            'zstd,1',
-            'zstd,3',
-            'zstd,5',
-            'zstd,10',
-            'zstd,16',
-            'zstd,22',
-            'zlib,0',
-            'zlib,6',
-            'zlib,9',
-            'lzma,0',
-            'lzma,6',
-            'lzma,9',
+            "lz4",
+            "zstd,1",
+            "zstd,3",
+            "zstd,5",
+            "zstd,10",
+            "zstd,16",
+            "zstd,22",
+            "zlib,0",
+            "zlib,6",
+            "zlib,9",
+            "lzma,0",
+            "lzma,6",
+            "lzma,9",
         ]:
             compressor = CompressionSpec(spec).compressor
             size = "0.1GB"
@@ -783,14 +908,14 @@ class Archiver:
 
         print("msgpack ========================================================")
         item = Item(path="/foo/bar/baz", mode=660, mtime=1234567)
-        items = [item.as_dict(), ] * 1000
+        items = [item.as_dict()] * 1000
         size = "100k Items"
         spec = "msgpack"
         print(f"{spec:<12} {size:<10} {timeit(lambda: msgpack.packb(items), number=100):.3f}s")
 
         return 0
 
-    @with_repository(fake='dry_run', exclusive=True, compatibility=(Manifest.Operation.WRITE,))
+    @with_repository(fake="dry_run", exclusive=True, compatibility=(Manifest.Operation.WRITE,))
     def do_create(self, args, repository, manifest=None, key=None):
         """Create new archive"""
         matcher = PatternMatcher(fallback=True)
@@ -811,7 +936,7 @@ class Archiver:
                     skip_inodes.add((st.st_ino, st.st_dev))
                 except OSError:
                     pass
-            logger.debug('Processing files ...')
+            logger.debug("Processing files ...")
             if args.content_from_command:
                 path = args.stdin_name
                 mode = args.stdin_mode
@@ -822,93 +947,115 @@ class Archiver:
                         try:
                             proc = subprocess.Popen(args.paths, stdout=subprocess.PIPE)
                         except (FileNotFoundError, PermissionError) as e:
-                            self.print_error('Failed to execute command: %s', e)
+                            self.print_error("Failed to execute command: %s", e)
                             return self.exit_code
-                        status = fso.process_pipe(path=path, cache=cache, fd=proc.stdout, mode=mode, user=user, group=group)
+                        status = fso.process_pipe(
+                            path=path, cache=cache, fd=proc.stdout, mode=mode, user=user, group=group
+                        )
                         rc = proc.wait()
                         if rc != 0:
-                            self.print_error('Command %r exited with status %d', args.paths[0], rc)
+                            self.print_error("Command %r exited with status %d", args.paths[0], rc)
                             return self.exit_code
                     except BackupOSError as e:
-                        self.print_error('%s: %s', path, e)
+                        self.print_error("%s: %s", path, e)
                         return self.exit_code
                 else:
-                    status = '-'
+                    status = "-"
                 self.print_file_status(status, path)
             elif args.paths_from_command or args.paths_from_stdin:
-                paths_sep = eval_escapes(args.paths_delimiter) if args.paths_delimiter is not None else '\n'
+                paths_sep = eval_escapes(args.paths_delimiter) if args.paths_delimiter is not None else "\n"
                 if args.paths_from_command:
                     try:
                         proc = subprocess.Popen(args.paths, stdout=subprocess.PIPE)
                     except (FileNotFoundError, PermissionError) as e:
-                        self.print_error('Failed to execute command: %s', e)
+                        self.print_error("Failed to execute command: %s", e)
                         return self.exit_code
                     pipe_bin = proc.stdout
                 else:  # args.paths_from_stdin == True
                     pipe_bin = sys.stdin.buffer
-                pipe = TextIOWrapper(pipe_bin, errors='surrogateescape')
+                pipe = TextIOWrapper(pipe_bin, errors="surrogateescape")
                 for path in iter_separated(pipe, paths_sep):
                     path = os.path.normpath(path)
                     try:
-                        with backup_io('stat'):
+                        with backup_io("stat"):
                             st = os_stat(path=path, parent_fd=None, name=None, follow_symlinks=False)
-                        status = self._process_any(path=path, parent_fd=None, name=None, st=st, fso=fso,
-                                                   cache=cache, read_special=args.read_special, dry_run=dry_run)
+                        status = self._process_any(
+                            path=path,
+                            parent_fd=None,
+                            name=None,
+                            st=st,
+                            fso=fso,
+                            cache=cache,
+                            read_special=args.read_special,
+                            dry_run=dry_run,
+                        )
                     except (BackupOSError, BackupError) as e:
-                        self.print_warning('%s: %s', path, e)
-                        status = 'E'
-                    if status == 'C':
-                        self.print_warning('%s: file changed while we backed it up', path)
+                        self.print_warning("%s: %s", path, e)
+                        status = "E"
+                    if status == "C":
+                        self.print_warning("%s: file changed while we backed it up", path)
                     self.print_file_status(status, path)
                 if args.paths_from_command:
                     rc = proc.wait()
                     if rc != 0:
-                        self.print_error('Command %r exited with status %d', args.paths[0], rc)
+                        self.print_error("Command %r exited with status %d", args.paths[0], rc)
                         return self.exit_code
             else:
                 for path in args.paths:
-                    if path == '-':  # stdin
+                    if path == "-":  # stdin
                         path = args.stdin_name
                         mode = args.stdin_mode
                         user = args.stdin_user
                         group = args.stdin_group
                         if not dry_run:
                             try:
-                                status = fso.process_pipe(path=path, cache=cache, fd=sys.stdin.buffer, mode=mode, user=user, group=group)
+                                status = fso.process_pipe(
+                                    path=path, cache=cache, fd=sys.stdin.buffer, mode=mode, user=user, group=group
+                                )
                             except BackupOSError as e:
-                                status = 'E'
-                                self.print_warning('%s: %s', path, e)
+                                status = "E"
+                                self.print_warning("%s: %s", path, e)
                         else:
-                            status = '-'
+                            status = "-"
                         self.print_file_status(status, path)
                         continue
                     path = os.path.normpath(path)
-                    parent_dir = os.path.dirname(path) or '.'
+                    parent_dir = os.path.dirname(path) or "."
                     name = os.path.basename(path)
                     try:
                         # note: for path == '/':  name == '' and parent_dir == '/'.
                         # the empty name will trigger a fall-back to path-based processing in os_stat and os_open.
-                        with OsOpen(path=parent_dir, flags=flags_root, noatime=True, op='open_root') as parent_fd:
+                        with OsOpen(path=parent_dir, flags=flags_root, noatime=True, op="open_root") as parent_fd:
                             try:
                                 st = os_stat(path=path, parent_fd=parent_fd, name=name, follow_symlinks=False)
                             except OSError as e:
-                                self.print_warning('%s: %s', path, e)
+                                self.print_warning("%s: %s", path, e)
                                 continue
                             if args.one_file_system:
                                 restrict_dev = st.st_dev
                             else:
                                 restrict_dev = None
-                            self._rec_walk(path=path, parent_fd=parent_fd, name=name,
-                                           fso=fso, cache=cache, matcher=matcher,
-                                           exclude_caches=args.exclude_caches, exclude_if_present=args.exclude_if_present,
-                                           keep_exclude_tags=args.keep_exclude_tags, skip_inodes=skip_inodes,
-                                           restrict_dev=restrict_dev, read_special=args.read_special, dry_run=dry_run)
+                            self._rec_walk(
+                                path=path,
+                                parent_fd=parent_fd,
+                                name=name,
+                                fso=fso,
+                                cache=cache,
+                                matcher=matcher,
+                                exclude_caches=args.exclude_caches,
+                                exclude_if_present=args.exclude_if_present,
+                                keep_exclude_tags=args.keep_exclude_tags,
+                                skip_inodes=skip_inodes,
+                                restrict_dev=restrict_dev,
+                                read_special=args.read_special,
+                                dry_run=dry_run,
+                            )
                             # if we get back here, we've finished recursing into <path>,
                             # we do not ever want to get back in there (even if path is given twice as recursion root)
                             skip_inodes.add((st.st_ino, st.st_dev))
                     except (BackupOSError, BackupError) as e:
                         # this comes from OsOpen, self._rec_walk has own exception handler
-                        self.print_warning('%s: %s', path, e)
+                        self.print_warning("%s: %s", path, e)
                         continue
             if not dry_run:
                 if args.progress:
@@ -923,13 +1070,9 @@ class Archiver:
                     args.stats |= args.json
                     if args.stats:
                         if args.json:
-                            json_print(basic_json_data(manifest, cache=cache, extra={
-                                'archive': archive,
-                            }))
+                            json_print(basic_json_data(manifest, cache=cache, extra={"archive": archive}))
                         else:
-                            log_multi(str(archive),
-                                      str(archive.stats),
-                                      logger=logging.getLogger('borg.output.stats'))
+                            log_multi(str(archive), str(archive.stats), logger=logging.getLogger("borg.output.stats"))
 
         self.output_filter = args.output_filter
         self.output_list = args.output_list
@@ -942,25 +1085,64 @@ class Archiver:
         t0_monotonic = time.monotonic()
         logger.info('Creating archive at "%s"' % args.location.processed)
         if not dry_run:
-            with Cache(repository, key, manifest, progress=args.progress,
-                       lock_wait=self.lock_wait, permit_adhoc_cache=args.no_cache_sync,
-                       cache_mode=args.files_cache_mode, iec=args.iec) as cache:
-                archive = Archive(repository, key, manifest, args.name, cache=cache,
-                                  create=True, checkpoint_interval=args.checkpoint_interval,
-                                  numeric_ids=args.numeric_ids, noatime=not args.atime, noctime=args.noctime,
-                                  progress=args.progress,
-                                  chunker_params=args.chunker_params, start=t0, start_monotonic=t0_monotonic,
-                                  log_json=args.log_json, iec=args.iec)
-                metadata_collector = MetadataCollector(noatime=not args.atime, noctime=args.noctime,
-                    noflags=args.noflags, noacls=args.noacls, noxattrs=args.noxattrs,
-                    numeric_ids=args.numeric_ids, nobirthtime=args.nobirthtime)
-                cp = ChunksProcessor(cache=cache, key=key,
-                    add_item=archive.add_item, write_checkpoint=archive.write_checkpoint,
-                    checkpoint_interval=args.checkpoint_interval, rechunkify=False)
-                fso = FilesystemObjectProcessors(metadata_collector=metadata_collector, cache=cache, key=key,
-                    process_file_chunks=cp.process_file_chunks, add_item=archive.add_item,
-                    chunker_params=args.chunker_params, show_progress=args.progress, sparse=args.sparse,
-                    log_json=args.log_json, iec=args.iec, file_status_printer=self.print_file_status)
+            with Cache(
+                repository,
+                key,
+                manifest,
+                progress=args.progress,
+                lock_wait=self.lock_wait,
+                permit_adhoc_cache=args.no_cache_sync,
+                cache_mode=args.files_cache_mode,
+                iec=args.iec,
+            ) as cache:
+                archive = Archive(
+                    repository,
+                    key,
+                    manifest,
+                    args.name,
+                    cache=cache,
+                    create=True,
+                    checkpoint_interval=args.checkpoint_interval,
+                    numeric_ids=args.numeric_ids,
+                    noatime=not args.atime,
+                    noctime=args.noctime,
+                    progress=args.progress,
+                    chunker_params=args.chunker_params,
+                    start=t0,
+                    start_monotonic=t0_monotonic,
+                    log_json=args.log_json,
+                    iec=args.iec,
+                )
+                metadata_collector = MetadataCollector(
+                    noatime=not args.atime,
+                    noctime=args.noctime,
+                    noflags=args.noflags,
+                    noacls=args.noacls,
+                    noxattrs=args.noxattrs,
+                    numeric_ids=args.numeric_ids,
+                    nobirthtime=args.nobirthtime,
+                )
+                cp = ChunksProcessor(
+                    cache=cache,
+                    key=key,
+                    add_item=archive.add_item,
+                    write_checkpoint=archive.write_checkpoint,
+                    checkpoint_interval=args.checkpoint_interval,
+                    rechunkify=False,
+                )
+                fso = FilesystemObjectProcessors(
+                    metadata_collector=metadata_collector,
+                    cache=cache,
+                    key=key,
+                    process_file_chunks=cp.process_file_chunks,
+                    add_item=archive.add_item,
+                    chunker_params=args.chunker_params,
+                    show_progress=args.progress,
+                    sparse=args.sparse,
+                    log_json=args.log_json,
+                    iec=args.iec,
+                    file_status_printer=self.print_file_status,
+                )
                 create_inner(archive, cache, fso)
         else:
             create_inner(None, None, None)
@@ -972,7 +1154,7 @@ class Archiver:
         """
 
         if dry_run:
-            return '-'
+            return "-"
         elif stat.S_ISREG(st.st_mode):
             return fso.process_file(path=path, parent_fd=parent_fd, name=name, st=st, cache=cache)
         elif stat.S_ISDIR(st.st_mode):
@@ -988,28 +1170,32 @@ class Archiver:
                 else:
                     special = is_special(st_target.st_mode)
                 if special:
-                    return fso.process_file(path=path, parent_fd=parent_fd, name=name, st=st_target,
-                                              cache=cache, flags=flags_special_follow)
+                    return fso.process_file(
+                        path=path, parent_fd=parent_fd, name=name, st=st_target, cache=cache, flags=flags_special_follow
+                    )
                 else:
                     return fso.process_symlink(path=path, parent_fd=parent_fd, name=name, st=st)
         elif stat.S_ISFIFO(st.st_mode):
             if not read_special:
                 return fso.process_fifo(path=path, parent_fd=parent_fd, name=name, st=st)
             else:
-                return fso.process_file(path=path, parent_fd=parent_fd, name=name, st=st,
-                                        cache=cache, flags=flags_special)
+                return fso.process_file(
+                    path=path, parent_fd=parent_fd, name=name, st=st, cache=cache, flags=flags_special
+                )
         elif stat.S_ISCHR(st.st_mode):
             if not read_special:
-                return fso.process_dev(path=path, parent_fd=parent_fd, name=name, st=st, dev_type='c')
+                return fso.process_dev(path=path, parent_fd=parent_fd, name=name, st=st, dev_type="c")
             else:
-                return fso.process_file(path=path, parent_fd=parent_fd, name=name, st=st,
-                                        cache=cache, flags=flags_special)
+                return fso.process_file(
+                    path=path, parent_fd=parent_fd, name=name, st=st, cache=cache, flags=flags_special
+                )
         elif stat.S_ISBLK(st.st_mode):
             if not read_special:
-                return fso.process_dev(path=path, parent_fd=parent_fd, name=name, st=st, dev_type='b')
+                return fso.process_dev(path=path, parent_fd=parent_fd, name=name, st=st, dev_type="b")
             else:
-                return fso.process_file(path=path, parent_fd=parent_fd, name=name, st=st,
-                                        cache=cache, flags=flags_special)
+                return fso.process_file(
+                    path=path, parent_fd=parent_fd, name=name, st=st, cache=cache, flags=flags_special
+                )
         elif stat.S_ISSOCK(st.st_mode):
             # Ignore unix sockets
             return
@@ -1020,12 +1206,26 @@ class Archiver:
             # Ignore Solaris event ports
             return
         else:
-            self.print_warning('Unknown file type: %s', path)
+            self.print_warning("Unknown file type: %s", path)
             return
 
-    def _rec_walk(self, *, path, parent_fd, name, fso, cache, matcher,
-                  exclude_caches, exclude_if_present, keep_exclude_tags,
-                  skip_inodes, restrict_dev, read_special, dry_run):
+    def _rec_walk(
+        self,
+        *,
+        path,
+        parent_fd,
+        name,
+        fso,
+        cache,
+        matcher,
+        exclude_caches,
+        exclude_if_present,
+        keep_exclude_tags,
+        skip_inodes,
+        restrict_dev,
+        read_special,
+        dry_run,
+    ):
         """
         Process *path* (or, preferably, parent_fd/name) recursively according to the various parameters.
 
@@ -1039,10 +1239,10 @@ class Archiver:
         try:
             recurse_excluded_dir = False
             if matcher.match(path):
-                with backup_io('stat'):
+                with backup_io("stat"):
                     st = os_stat(path=path, parent_fd=parent_fd, name=name, follow_symlinks=False)
             else:
-                self.print_file_status('x', path)
+                self.print_file_status("x", path)
                 # get out here as quickly as possible:
                 # we only need to continue if we shall recurse into an excluded directory.
                 # if we shall not recurse, then do not even touch (stat()) the item, it
@@ -1050,7 +1250,7 @@ class Archiver:
                 if not matcher.recurse_dir:
                     return
                 recurse_excluded_dir = True
-                with backup_io('stat'):
+                with backup_io("stat"):
                     st = os_stat(path=path, parent_fd=parent_fd, name=name, follow_symlinks=False)
                 if not stat.S_ISDIR(st.st_mode):
                     return
@@ -1064,22 +1264,31 @@ class Archiver:
 
             if self.exclude_nodump:
                 # Ignore if nodump flag is set
-                with backup_io('flags'):
+                with backup_io("flags"):
                     if get_flags(path=path, st=st) & stat.UF_NODUMP:
-                        self.print_file_status('x', path)
+                        self.print_file_status("x", path)
                         return
 
             if not stat.S_ISDIR(st.st_mode):
                 # directories cannot go in this branch because they can be excluded based on tag
                 # files they might contain
-                status = self._process_any(path=path, parent_fd=parent_fd, name=name, st=st, fso=fso, cache=cache,
-                                           read_special=read_special, dry_run=dry_run)
+                status = self._process_any(
+                    path=path,
+                    parent_fd=parent_fd,
+                    name=name,
+                    st=st,
+                    fso=fso,
+                    cache=cache,
+                    read_special=read_special,
+                    dry_run=dry_run,
+                )
             else:
-                with OsOpen(path=path, parent_fd=parent_fd, name=name, flags=flags_dir,
-                            noatime=True, op='dir_open') as child_fd:
+                with OsOpen(
+                    path=path, parent_fd=parent_fd, name=name, flags=flags_dir, noatime=True, op="dir_open"
+                ) as child_fd:
                     # child_fd is None for directories on windows, in that case a race condition check is not possible.
                     if child_fd is not None:
-                        with backup_io('fstat'):
+                        with backup_io("fstat"):
                             st = stat_update_check(st, os.fstat(child_fd))
                     if recurse:
                         tag_names = dir_is_tagged(path, exclude_caches, exclude_if_present)
@@ -1093,43 +1302,67 @@ class Archiver:
                                     for tag_name in tag_names:
                                         tag_path = os.path.join(path, tag_name)
                                         self._rec_walk(
-                                                path=tag_path, parent_fd=child_fd, name=tag_name, fso=fso, cache=cache,
-                                                matcher=matcher, exclude_caches=exclude_caches, exclude_if_present=exclude_if_present,
-                                                keep_exclude_tags=keep_exclude_tags, skip_inodes=skip_inodes,
-                                                restrict_dev=restrict_dev, read_special=read_special, dry_run=dry_run)
-                                self.print_file_status('x', path)
+                                            path=tag_path,
+                                            parent_fd=child_fd,
+                                            name=tag_name,
+                                            fso=fso,
+                                            cache=cache,
+                                            matcher=matcher,
+                                            exclude_caches=exclude_caches,
+                                            exclude_if_present=exclude_if_present,
+                                            keep_exclude_tags=keep_exclude_tags,
+                                            skip_inodes=skip_inodes,
+                                            restrict_dev=restrict_dev,
+                                            read_special=read_special,
+                                            dry_run=dry_run,
+                                        )
+                                self.print_file_status("x", path)
                             return
                     if not recurse_excluded_dir and not dry_run:
                         status = fso.process_dir_with_fd(path=path, fd=child_fd, st=st)
                     if recurse:
-                        with backup_io('scandir'):
+                        with backup_io("scandir"):
                             entries = helpers.scandir_inorder(path=path, fd=child_fd)
                         for dirent in entries:
                             normpath = os.path.normpath(os.path.join(path, dirent.name))
                             self._rec_walk(
-                                    path=normpath, parent_fd=child_fd, name=dirent.name, fso=fso, cache=cache, matcher=matcher,
-                                    exclude_caches=exclude_caches, exclude_if_present=exclude_if_present,
-                                    keep_exclude_tags=keep_exclude_tags, skip_inodes=skip_inodes, restrict_dev=restrict_dev,
-                                    read_special=read_special, dry_run=dry_run)
+                                path=normpath,
+                                parent_fd=child_fd,
+                                name=dirent.name,
+                                fso=fso,
+                                cache=cache,
+                                matcher=matcher,
+                                exclude_caches=exclude_caches,
+                                exclude_if_present=exclude_if_present,
+                                keep_exclude_tags=keep_exclude_tags,
+                                skip_inodes=skip_inodes,
+                                restrict_dev=restrict_dev,
+                                read_special=read_special,
+                                dry_run=dry_run,
+                            )
 
         except (BackupOSError, BackupError) as e:
-            self.print_warning('%s: %s', path, e)
-            status = 'E'
-        if status == 'C':
-            self.print_warning('%s: file changed while we backed it up', path)
+            self.print_warning("%s: %s", path, e)
+            status = "E"
+        if status == "C":
+            self.print_warning("%s: file changed while we backed it up", path)
         if not recurse_excluded_dir:
             self.print_file_status(status, path)
 
     @staticmethod
     def build_filter(matcher, strip_components):
         if strip_components:
+
             def item_filter(item):
                 matched = matcher.match(item.path) and os.sep.join(item.path.split(os.sep)[strip_components:])
                 return matched
+
         else:
+
             def item_filter(item):
                 matched = matcher.match(item.path)
                 return matched
+
         return item_filter
 
     @with_repository(compatibility=(Manifest.Operation.READ,))
@@ -1137,10 +1370,14 @@ class Archiver:
     def do_extract(self, args, repository, manifest, key, archive):
         """Extract archive contents"""
         # be restrictive when restoring files, restore permissions later
-        if sys.getfilesystemencoding() == 'ascii':
-            logger.warning('Warning: File system encoding is "ascii", extracting non-ascii filenames will not be supported.')
-            if sys.platform.startswith(('linux', 'freebsd', 'netbsd', 'openbsd', 'darwin', )):
-                logger.warning('Hint: You likely need to fix your locale setup. E.g. install locales and use: LANG=en_US.UTF-8')
+        if sys.getfilesystemencoding() == "ascii":
+            logger.warning(
+                'Warning: File system encoding is "ascii", extracting non-ascii filenames will not be supported.'
+            )
+            if sys.platform.startswith(("linux", "freebsd", "netbsd", "openbsd", "darwin")):
+                logger.warning(
+                    "Hint: You likely need to fix your locale setup. E.g. install locales and use: LANG=en_US.UTF-8"
+                )
 
         matcher = self.build_matcher(args.patterns, args.paths)
 
@@ -1155,8 +1392,8 @@ class Archiver:
 
         filter = self.build_filter(matcher, strip_components)
         if progress:
-            pi = ProgressIndicatorPercent(msg='%5.1f%% Extracting: %s', step=0.1, msgid='extract')
-            pi.output('Calculating total archive size for the progress indicator (might take long for large archives)')
+            pi = ProgressIndicatorPercent(msg="%5.1f%% Extracting: %s", step=0.1, msgid="extract")
+            pi.output("Calculating total archive size for the progress indicator (might take long for large archives)")
             extracted_size = sum(item.get_size() for item in archive.iter_items(filter))
             pi.total = extracted_size
         else:
@@ -1172,9 +1409,9 @@ class Archiver:
                     try:
                         archive.extract_item(dir_item, stdout=stdout)
                     except BackupOSError as e:
-                        self.print_warning('%s: %s', remove_surrogates(dir_item.path), e)
+                        self.print_warning("%s: %s", remove_surrogates(dir_item.path), e)
             if output_list:
-                logging.getLogger('borg.output.list').info(remove_surrogates(item.path))
+                logging.getLogger("borg.output.list").info(remove_surrogates(item.path))
             try:
                 if dry_run:
                     archive.extract_item(item, dry_run=True, hlm=hlm, pi=pi)
@@ -1183,24 +1420,32 @@ class Archiver:
                         dirs.append(item)
                         archive.extract_item(item, stdout=stdout, restore_attrs=False)
                     else:
-                        archive.extract_item(item, stdout=stdout, sparse=sparse, hlm=hlm,
-                                             stripped_components=strip_components, original_path=orig_path, pi=pi)
+                        archive.extract_item(
+                            item,
+                            stdout=stdout,
+                            sparse=sparse,
+                            hlm=hlm,
+                            stripped_components=strip_components,
+                            original_path=orig_path,
+                            pi=pi,
+                        )
             except (BackupOSError, BackupError) as e:
-                self.print_warning('%s: %s', remove_surrogates(orig_path), e)
+                self.print_warning("%s: %s", remove_surrogates(orig_path), e)
 
         if pi:
             pi.finish()
 
         if not args.dry_run:
-            pi = ProgressIndicatorPercent(total=len(dirs), msg='Setting directory permissions %3.0f%%',
-                                          msgid='extract.permissions')
+            pi = ProgressIndicatorPercent(
+                total=len(dirs), msg="Setting directory permissions %3.0f%%", msgid="extract.permissions"
+            )
             while dirs:
                 pi.show()
                 dir_item = dirs.pop(-1)
                 try:
                     archive.extract_item(dir_item, stdout=stdout)
                 except BackupOSError as e:
-                    self.print_warning('%s: %s', remove_surrogates(dir_item.path), e)
+                    self.print_warning("%s: %s", remove_surrogates(dir_item.path), e)
         for pattern in matcher.get_unmatched_include_patterns():
             self.print_warning("Include pattern '%s' never matched.", pattern)
         if pi:
@@ -1232,10 +1477,10 @@ class Archiver:
         # that it has to be installed -- hardly a problem, considering that
         # the decompressor must be installed as well to make use of the exported tarball!
 
-        filter = get_tar_filter(args.tarfile, decompress=False) if args.tar_filter == 'auto' else args.tar_filter
+        filter = get_tar_filter(args.tarfile, decompress=False) if args.tar_filter == "auto" else args.tar_filter
 
-        tarstream = dash_open(args.tarfile, 'wb')
-        tarstream_close = args.tarfile != '-'
+        tarstream = dash_open(args.tarfile, "wb")
+        tarstream_close = args.tarfile != "-"
 
         with create_filter_process(filter, stream=tarstream, stream_close=tarstream_close, inbound=False) as _stream:
             self._export_tar(args, archive, _stream)
@@ -1255,11 +1500,11 @@ class Archiver:
         # The | (pipe) symbol instructs tarfile to use a streaming mode of operation
         # where it never seeks on the passed fileobj.
         tar_format = dict(GNU=tarfile.GNU_FORMAT, PAX=tarfile.PAX_FORMAT, BORG=tarfile.PAX_FORMAT)[args.tar_format]
-        tar = tarfile.open(fileobj=tarstream, mode='w|', format=tar_format)
+        tar = tarfile.open(fileobj=tarstream, mode="w|", format=tar_format)
 
         if progress:
-            pi = ProgressIndicatorPercent(msg='%5.1f%% Processing: %s', step=0.1, msgid='extract')
-            pi.output('Calculating size')
+            pi = ProgressIndicatorPercent(msg="%5.1f%% Processing: %s", step=0.1, msgid="extract")
+            pi.output("Calculating size")
             extracted_size = sum(item.get_size() for item in archive.iter_items(filter))
             pi.total = extracted_size
         else:
@@ -1269,12 +1514,12 @@ class Archiver:
             """
             Return a file-like object that reads from the chunks of *item*.
             """
-            chunk_iterator = archive.pipeline.fetch_many([chunk_id for chunk_id, _ in item.chunks],
-                                                         is_preloaded=True)
+            chunk_iterator = archive.pipeline.fetch_many([chunk_id for chunk_id, _ in item.chunks], is_preloaded=True)
             if pi:
                 info = [remove_surrogates(item.path)]
-                return ChunkIteratorFileWrapper(chunk_iterator,
-                                                lambda read_bytes: pi.show(increase=len(read_bytes), info=info))
+                return ChunkIteratorFileWrapper(
+                    chunk_iterator, lambda read_bytes: pi.show(increase=len(read_bytes), info=info)
+                )
             else:
                 return ChunkIteratorFileWrapper(chunk_iterator)
 
@@ -1293,8 +1538,8 @@ class Archiver:
             tarinfo.mode = stat.S_IMODE(item.mode)
             tarinfo.uid = item.uid
             tarinfo.gid = item.gid
-            tarinfo.uname = item.get('user', '')
-            tarinfo.gname = item.get('group', '')
+            tarinfo.uname = item.get("user", "")
+            tarinfo.gname = item.get("group", "")
             # The linkname in tar has 2 uses:
             # for symlinks it means the destination, while for hardlinks it refers to the file.
             # Since hardlinks in tar have a different type code (LNKTYPE) the format might
@@ -1305,7 +1550,7 @@ class Archiver:
             modebits = stat.S_IFMT(item.mode)
             if modebits == stat.S_IFREG:
                 tarinfo.type = tarfile.REGTYPE
-                if 'hlid' in item:
+                if "hlid" in item:
                     linkname = hlm.retrieve(id=item.hlid)
                     if linkname is not None:
                         # the first hardlink was already added to the archive, add a tar-hardlink reference to it.
@@ -1334,7 +1579,9 @@ class Archiver:
             elif modebits == stat.S_IFIFO:
                 tarinfo.type = tarfile.FIFOTYPE
             else:
-                self.print_warning('%s: unsupported file type %o for tar export', remove_surrogates(item.path), modebits)
+                self.print_warning(
+                    "%s: unsupported file type %o for tar export", remove_surrogates(item.path), modebits
+                )
                 set_ec(EXIT_WARNING)
                 return None, stream
             return tarinfo, stream
@@ -1360,16 +1607,16 @@ class Archiver:
             ph = {}
             # note: for mtime this is a bit redundant as it is already done by tarfile module,
             #       but we just do it in our way to be consistent for sure.
-            for name in 'atime', 'ctime', 'mtime':
+            for name in "atime", "ctime", "mtime":
                 if hasattr(item, name):
                     ns = getattr(item, name)
                     ph[name] = str(ns / 1e9)
-            if format == 'BORG':  # BORG format additions
-                ph['BORG.item.version'] = '1'
+            if format == "BORG":  # BORG format additions
+                ph["BORG.item.version"] = "1"
                 # BORG.item.meta - just serialize all metadata we have:
                 meta_bin = msgpack.packb(item.as_dict())
                 meta_text = base64.b64encode(meta_bin).decode()
-                ph['BORG.item.meta'] = meta_text
+                ph["BORG.item.meta"] = meta_text
             return ph
 
         for item in archive.iter_items(filter, preload=True):
@@ -1378,10 +1625,10 @@ class Archiver:
                 item.path = os.sep.join(orig_path.split(os.sep)[strip_components:])
             tarinfo, stream = item_to_tarinfo(item, orig_path)
             if tarinfo:
-                if args.tar_format in ('BORG', 'PAX'):
+                if args.tar_format in ("BORG", "PAX"):
                     tarinfo.pax_headers = item_to_paxheaders(args.tar_format, item)
                 if output_list:
-                    logging.getLogger('borg.output.list').info(remove_surrogates(orig_path))
+                    logging.getLogger("borg.output.list").info(remove_surrogates(orig_path))
                 tar.addfile(tarinfo, stream)
 
         if pi:
@@ -1403,20 +1650,23 @@ class Archiver:
             print(json.dumps({"path": path, "changes": [j for j, str in diff]}))
 
         def print_text_output(diff, path):
-            print("{:<19} {}".format(' '.join([str for j, str in diff]), path))
+            print("{:<19} {}".format(" ".join([str for j, str in diff]), path))
 
         print_output = print_json_output if args.json_lines else print_text_output
 
         archive1 = archive
-        archive2 = Archive(repository, key, manifest, args.other_name,
-                           consider_part_files=args.consider_part_files)
+        archive2 = Archive(repository, key, manifest, args.other_name, consider_part_files=args.consider_part_files)
 
-        can_compare_chunk_ids = archive1.metadata.get('chunker_params', False) == archive2.metadata.get(
-            'chunker_params', True) or args.same_chunker_params
+        can_compare_chunk_ids = (
+            archive1.metadata.get("chunker_params", False) == archive2.metadata.get("chunker_params", True)
+            or args.same_chunker_params
+        )
         if not can_compare_chunk_ids:
-            self.print_warning('--chunker-params might be different between archives, diff will be slow.\n'
-                               'If you know for certain that they are the same, pass --same-chunker-params '
-                               'to override this check.')
+            self.print_warning(
+                "--chunker-params might be different between archives, diff will be slow.\n"
+                "If you know for certain that they are the same, pass --same-chunker-params "
+                "to override this check."
+            )
 
         matcher = self.build_matcher(args.patterns, args.paths)
 
@@ -1460,12 +1710,16 @@ class Archiver:
                 try:
                     manifest, key = Manifest.load(repository, Manifest.NO_OPERATION_CHECK)
                     n_archives = len(manifest.archives)
-                    msg.append(f"You requested to completely DELETE the following repository "
-                               f"*including* {n_archives} archives it contains:")
+                    msg.append(
+                        f"You requested to completely DELETE the following repository "
+                        f"*including* {n_archives} archives it contains:"
+                    )
                 except NoManifestError:
                     n_archives = None
-                    msg.append("You requested to completely DELETE the following repository "
-                               "*including* all archives it may contain:")
+                    msg.append(
+                        "You requested to completely DELETE the following repository "
+                        "*including* all archives it may contain:"
+                    )
 
                 msg.append(DASHES)
                 msg.append(f"Repository ID: {id}")
@@ -1477,19 +1731,27 @@ class Archiver:
 
                     if n_archives is not None:
                         if n_archives > 0:
-                            for archive_info in manifest.archives.list(sort_by=['ts']):
+                            for archive_info in manifest.archives.list(sort_by=["ts"]):
                                 msg.append(format_archive(archive_info))
                         else:
                             msg.append("This repository seems to not have any archives.")
                     else:
-                        msg.append("This repository seems to have no manifest, so we can't "
-                                   "tell anything about its contents.")
+                        msg.append(
+                            "This repository seems to have no manifest, so we can't "
+                            "tell anything about its contents."
+                        )
 
                 msg.append(DASHES)
                 msg.append("Type 'YES' if you understand this and want to continue: ")
-                msg = '\n'.join(msg)
-                if not yes(msg, false_msg="Aborting.", invalid_msg='Invalid answer, aborting.', truish=('YES',),
-                           retry=False, env_var_override='BORG_DELETE_I_KNOW_WHAT_I_AM_DOING'):
+                msg = "\n".join(msg)
+                if not yes(
+                    msg,
+                    false_msg="Aborting.",
+                    invalid_msg="Invalid answer, aborting.",
+                    truish=("YES",),
+                    retry=False,
+                    env_var_override="BORG_DELETE_I_KNOW_WHAT_I_AM_DOING",
+                ):
                     self.exit_code = EXIT_ERROR
                     return self.exit_code
             if not dry_run:
@@ -1517,41 +1779,42 @@ class Archiver:
         if not archive_names:
             return self.exit_code
         if args.glob_archives is None and args.first == 0 and args.last == 0:
-            self.print_error("Aborting: if you really want to delete all archives, please use -a '*' "
-                             "or just delete the whole repository (might be much faster).")
+            self.print_error(
+                "Aborting: if you really want to delete all archives, please use -a '*' "
+                "or just delete the whole repository (might be much faster)."
+            )
             return EXIT_ERROR
 
         if args.forced == 2:
             deleted = False
-            logger_list = logging.getLogger('borg.output.list')
+            logger_list = logging.getLogger("borg.output.list")
             for i, archive_name in enumerate(archive_names, 1):
                 try:
                     current_archive = manifest.archives.pop(archive_name)
                 except KeyError:
                     self.exit_code = EXIT_WARNING
-                    logger.warning(f'Archive {archive_name} not found ({i}/{len(archive_names)}).')
+                    logger.warning(f"Archive {archive_name} not found ({i}/{len(archive_names)}).")
                 else:
                     deleted = True
                     if self.output_list:
-                        msg = 'Would delete: {} ({}/{})' if dry_run else 'Deleted archive: {} ({}/{})'
-                        logger_list.info(msg.format(format_archive(current_archive),
-                                                    i, len(archive_names)))
+                        msg = "Would delete: {} ({}/{})" if dry_run else "Deleted archive: {} ({}/{})"
+                        logger_list.info(msg.format(format_archive(current_archive), i, len(archive_names)))
             if dry_run:
-                logger.info('Finished dry-run.')
+                logger.info("Finished dry-run.")
             elif deleted:
                 manifest.write()
                 # note: might crash in compact() after committing the repo
                 repository.commit(compact=False)
                 logger.warning('Done. Run "borg check --repair" to clean up the mess.')
             else:
-                logger.warning('Aborted.')
+                logger.warning("Aborted.")
             return self.exit_code
 
         stats = Statistics(iec=args.iec)
         with Cache(repository, key, manifest, progress=args.progress, lock_wait=self.lock_wait, iec=args.iec) as cache:
-            msg_delete = 'Would delete archive: {} ({}/{})' if dry_run else 'Deleting archive: {} ({}/{})'
-            msg_not_found = 'Archive {} not found ({}/{}).'
-            logger_list = logging.getLogger('borg.output.list')
+            msg_delete = "Would delete archive: {} ({}/{})" if dry_run else "Deleting archive: {} ({}/{})"
+            msg_not_found = "Archive {} not found ({}/{})."
+            logger_list = logging.getLogger("borg.output.list")
             delete_count = 0
             for i, archive_name in enumerate(archive_names, 1):
                 try:
@@ -1563,8 +1826,14 @@ class Archiver:
                         logger_list.info(msg_delete.format(format_archive(archive_info), i, len(archive_names)))
 
                     if not dry_run:
-                        archive = Archive(repository, key, manifest, archive_name, cache=cache,
-                                          consider_part_files=args.consider_part_files)
+                        archive = Archive(
+                            repository,
+                            key,
+                            manifest,
+                            archive_name,
+                            cache=cache,
+                            consider_part_files=args.consider_part_files,
+                        )
                         archive.delete(stats, progress=args.progress, forced=args.forced)
                         delete_count += 1
             if delete_count > 0:
@@ -1573,8 +1842,7 @@ class Archiver:
                 repository.commit(compact=False, save_space=args.save_space)
                 cache.commit()
             if args.stats:
-                log_multi(str(stats),
-                          logger=logging.getLogger('borg.output.stats'))
+                log_multi(str(stats), logger=logging.getLogger("borg.output.stats"))
 
         return self.exit_code
 
@@ -1583,12 +1851,13 @@ class Archiver:
         # Perform these checks before opening the repository and asking for a passphrase.
 
         from .fuse_impl import llfuse, BORG_FUSE_IMPL
+
         if llfuse is None:
-            self.print_error('borg mount not available: no FUSE support, BORG_FUSE_IMPL=%s.' % BORG_FUSE_IMPL)
+            self.print_error("borg mount not available: no FUSE support, BORG_FUSE_IMPL=%s." % BORG_FUSE_IMPL)
             return self.exit_code
 
         if not os.path.isdir(args.mountpoint) or not os.access(args.mountpoint, os.R_OK | os.W_OK | os.X_OK):
-            self.print_error('%s: Mountpoint must be a writable directory' % args.mountpoint)
+            self.print_error("%s: Mountpoint must be a writable directory" % args.mountpoint)
             return self.exit_code
 
         return self._do_mount(args)
@@ -1623,8 +1892,9 @@ class Archiver:
             format = "{mode} {user:6} {group:6} {size:8} {mtime} {path}{extra}{NL}"
 
         def _list_inner(cache):
-            archive = Archive(repository, key, manifest, args.name, cache=cache,
-                              consider_part_files=args.consider_part_files)
+            archive = Archive(
+                repository, key, manifest, args.name, cache=cache, consider_part_files=args.consider_part_files
+            )
 
             formatter = ItemFormatter(archive, format, json_lines=args.json_lines)
             for item in archive.iter_items(lambda item: matcher.match(item.path)):
@@ -1659,32 +1929,30 @@ class Archiver:
                 sys.stdout.write(formatter.format_item(archive_info))
 
         if args.json:
-            json_print(basic_json_data(manifest, extra={
-                'archives': output_data
-            }))
+            json_print(basic_json_data(manifest, extra={"archives": output_data}))
 
         return self.exit_code
 
     @with_repository(cache=True, compatibility=(Manifest.Operation.READ,))
     def do_rinfo(self, args, repository, manifest, key, cache):
         """Show repository infos"""
-        info = basic_json_data(manifest, cache=cache, extra={
-            'security_dir': cache.security_manager.dir,
-        })
+        info = basic_json_data(manifest, cache=cache, extra={"security_dir": cache.security_manager.dir})
 
         if args.json:
             json_print(info)
         else:
-            encryption = 'Encrypted: '
-            if key.NAME in ('plaintext', 'authenticated'):
-                encryption += 'No'
+            encryption = "Encrypted: "
+            if key.NAME in ("plaintext", "authenticated"):
+                encryption += "No"
             else:
-                encryption += 'Yes (%s)' % key.NAME
-            if key.NAME.startswith('key file'):
-                encryption += '\nKey file: %s' % key.find_key()
-            info['encryption'] = encryption
+                encryption += "Yes (%s)" % key.NAME
+            if key.NAME.startswith("key file"):
+                encryption += "\nKey file: %s" % key.find_key()
+            info["encryption"] = encryption
 
-            print(textwrap.dedent("""
+            print(
+                textwrap.dedent(
+                    """
             Repository ID: {id}
             Location: {location}
             Repository version: {version}
@@ -1692,20 +1960,26 @@ class Archiver:
             {encryption}
             Cache: {cache.path}
             Security dir: {security_dir}
-            """).strip().format(
-                id=bin_to_hex(repository.id),
-                location=repository._location.canonical_path(),
-                version=repository.version,
-                append_only=repository.append_only,
-                **info))
+            """
+                )
+                .strip()
+                .format(
+                    id=bin_to_hex(repository.id),
+                    location=repository._location.canonical_path(),
+                    version=repository.version,
+                    append_only=repository.append_only,
+                    **info,
+                )
+            )
             print(str(cache))
         return self.exit_code
 
     @with_repository(cache=True, compatibility=(Manifest.Operation.READ,))
     def do_info(self, args, repository, manifest, key, cache):
         """Show archive details such as disk space used"""
+
         def format_cmdline(cmdline):
-            return remove_surrogates(' '.join(shlex.quote(x) for x in cmdline))
+            return remove_surrogates(" ".join(shlex.quote(x) for x in cmdline))
 
         args.consider_checkpoints = True
         archive_names = tuple(x.name for x in manifest.archives.list_considering(args))
@@ -1713,15 +1987,24 @@ class Archiver:
         output_data = []
 
         for i, archive_name in enumerate(archive_names, 1):
-            archive = Archive(repository, key, manifest, archive_name, cache=cache,
-                              consider_part_files=args.consider_part_files, iec=args.iec)
+            archive = Archive(
+                repository,
+                key,
+                manifest,
+                archive_name,
+                cache=cache,
+                consider_part_files=args.consider_part_files,
+                iec=args.iec,
+            )
             info = archive.info()
             if args.json:
                 output_data.append(info)
             else:
-                info['duration'] = format_timedelta(timedelta(seconds=info['duration']))
-                info['command_line'] = format_cmdline(info['command_line'])
-                print(textwrap.dedent("""
+                info["duration"] = format_timedelta(timedelta(seconds=info["duration"]))
+                info["command_line"] = format_cmdline(info["command_line"])
+                print(
+                    textwrap.dedent(
+                        """
                 Archive name: {name}
                 Archive fingerprint: {id}
                 Comment: {comment}
@@ -1735,33 +2018,41 @@ class Archiver:
                 Number of files: {stats[nfiles]}
                 Original size: {stats[original_size]}
                 Deduplicated size: {stats[deduplicated_size]}
-                """).strip().format(**info))
+                """
+                    )
+                    .strip()
+                    .format(**info)
+                )
             if self.exit_code:
                 break
             if not args.json and len(archive_names) - i:
                 print()
 
         if args.json:
-            json_print(basic_json_data(manifest, cache=cache, extra={
-                'archives': output_data,
-            }))
+            json_print(basic_json_data(manifest, cache=cache, extra={"archives": output_data}))
         return self.exit_code
 
     @with_repository(exclusive=True, compatibility=(Manifest.Operation.DELETE,))
     def do_prune(self, args, repository, manifest, key):
         """Prune repository archives according to specified rules"""
-        if not any((args.secondly, args.minutely, args.hourly, args.daily,
-                    args.weekly, args.monthly, args.yearly, args.within)):
-            self.print_error('At least one of the "keep-within", "keep-last", '
-                             '"keep-secondly", "keep-minutely", "keep-hourly", "keep-daily", '
-                             '"keep-weekly", "keep-monthly" or "keep-yearly" settings must be specified.')
+        if not any(
+            (args.secondly, args.minutely, args.hourly, args.daily, args.weekly, args.monthly, args.yearly, args.within)
+        ):
+            self.print_error(
+                'At least one of the "keep-within", "keep-last", '
+                '"keep-secondly", "keep-minutely", "keep-hourly", "keep-daily", '
+                '"keep-weekly", "keep-monthly" or "keep-yearly" settings must be specified.'
+            )
             return self.exit_code
-        checkpoint_re = r'\.checkpoint(\.\d+)?'
-        archives_checkpoints = manifest.archives.list(glob=args.glob_archives,
-                                                      consider_checkpoints=True,
-                                                      match_end=r'(%s)?\Z' % checkpoint_re,
-                                                      sort_by=['ts'], reverse=True)
-        is_checkpoint = re.compile(r'(%s)\Z' % checkpoint_re).search
+        checkpoint_re = r"\.checkpoint(\.\d+)?"
+        archives_checkpoints = manifest.archives.list(
+            glob=args.glob_archives,
+            consider_checkpoints=True,
+            match_end=r"(%s)?\Z" % checkpoint_re,
+            sort_by=["ts"],
+            reverse=True,
+        )
+        is_checkpoint = re.compile(r"(%s)\Z" % checkpoint_re).search
         checkpoints = [arch for arch in archives_checkpoints if is_checkpoint(arch.name)]
         # keep the latest checkpoint, if there is no later non-checkpoint archive
         if archives_checkpoints and checkpoints and archives_checkpoints[0] is checkpoints[0]:
@@ -1791,41 +2082,41 @@ class Archiver:
         to_delete = (set(archives) | checkpoints) - (set(keep) | set(keep_checkpoints))
         stats = Statistics(iec=args.iec)
         with Cache(repository, key, manifest, lock_wait=self.lock_wait, iec=args.iec) as cache:
-            list_logger = logging.getLogger('borg.output.list')
+            list_logger = logging.getLogger("borg.output.list")
             # set up counters for the progress display
             to_delete_len = len(to_delete)
             archives_deleted = 0
-            pi = ProgressIndicatorPercent(total=len(to_delete), msg='Pruning archives %3.0f%%', msgid='prune')
+            pi = ProgressIndicatorPercent(total=len(to_delete), msg="Pruning archives %3.0f%%", msgid="prune")
             for archive in archives_checkpoints:
                 if archive in to_delete:
                     pi.show()
                     if args.dry_run:
-                        log_message = 'Would prune:'
+                        log_message = "Would prune:"
                     else:
                         archives_deleted += 1
-                        log_message = 'Pruning archive (%d/%d):' % (archives_deleted, to_delete_len)
-                        archive = Archive(repository, key, manifest, archive.name, cache,
-                                          consider_part_files=args.consider_part_files)
+                        log_message = "Pruning archive (%d/%d):" % (archives_deleted, to_delete_len)
+                        archive = Archive(
+                            repository, key, manifest, archive.name, cache, consider_part_files=args.consider_part_files
+                        )
                         archive.delete(stats, forced=args.forced)
                 else:
                     if is_checkpoint(archive.name):
-                        log_message = 'Keeping checkpoint archive:'
+                        log_message = "Keeping checkpoint archive:"
                     else:
-                        log_message = 'Keeping archive (rule: {rule} #{num}):'.format(
+                        log_message = "Keeping archive (rule: {rule} #{num}):".format(
                             rule=kept_because[archive.id][0], num=kept_because[archive.id][1]
                         )
                 if args.output_list:
-                    list_logger.info("{message:<40} {archive}".format(
-                        message=log_message, archive=format_archive(archive)
-                    ))
+                    list_logger.info(
+                        "{message:<40} {archive}".format(message=log_message, archive=format_archive(archive))
+                    )
             pi.finish()
             if to_delete and not args.dry_run:
                 manifest.write()
                 repository.commit(compact=False, save_space=args.save_space)
                 cache.commit()
             if args.stats:
-                log_multi(str(stats),
-                          logger=logging.getLogger('borg.output.stats'))
+                log_multi(str(stats), logger=logging.getLogger("borg.output.stats"))
         return self.exit_code
 
     @with_repository(cache=True, exclusive=True, compatibility=(Manifest.Operation.CHECK,))
@@ -1834,28 +2125,40 @@ class Archiver:
         matcher = self.build_matcher(args.patterns, args.paths)
         self.output_list = args.output_list
         self.output_filter = args.output_filter
-        recompress = args.recompress != 'never'
-        always_recompress = args.recompress == 'always'
+        recompress = args.recompress != "never"
+        always_recompress = args.recompress == "always"
 
-        recreater = ArchiveRecreater(repository, manifest, key, cache, matcher,
-                                     exclude_caches=args.exclude_caches, exclude_if_present=args.exclude_if_present,
-                                     keep_exclude_tags=args.keep_exclude_tags, chunker_params=args.chunker_params,
-                                     compression=args.compression, recompress=recompress, always_recompress=always_recompress,
-                                     progress=args.progress, stats=args.stats,
-                                     file_status_printer=self.print_file_status,
-                                     checkpoint_interval=args.checkpoint_interval,
-                                     dry_run=args.dry_run, timestamp=args.timestamp)
+        recreater = ArchiveRecreater(
+            repository,
+            manifest,
+            key,
+            cache,
+            matcher,
+            exclude_caches=args.exclude_caches,
+            exclude_if_present=args.exclude_if_present,
+            keep_exclude_tags=args.keep_exclude_tags,
+            chunker_params=args.chunker_params,
+            compression=args.compression,
+            recompress=recompress,
+            always_recompress=always_recompress,
+            progress=args.progress,
+            stats=args.stats,
+            file_status_printer=self.print_file_status,
+            checkpoint_interval=args.checkpoint_interval,
+            dry_run=args.dry_run,
+            timestamp=args.timestamp,
+        )
 
         archive_names = tuple(archive.name for archive in manifest.archives.list_considering(args))
         if args.target is not None and len(archive_names) != 1:
-            self.print_error('--target: Need to specify single archive')
+            self.print_error("--target: Need to specify single archive")
             return self.exit_code
         for name in archive_names:
             if recreater.is_temporary_archive(name):
                 continue
-            print('Processing', name)
+            print("Processing", name)
             if not recreater.recreate(name, args.comment, args.target):
-                logger.info('Skipped archive %s: Nothing to do. Archive was not processed.', name)
+                logger.info("Skipped archive %s: Nothing to do. Archive was not processed.", name)
         if not args.dry_run:
             manifest.write()
             repository.commit(compact=False)
@@ -1868,10 +2171,10 @@ class Archiver:
         self.output_filter = args.output_filter
         self.output_list = args.output_list
 
-        filter = get_tar_filter(args.tarfile, decompress=True) if args.tar_filter == 'auto' else args.tar_filter
+        filter = get_tar_filter(args.tarfile, decompress=True) if args.tar_filter == "auto" else args.tar_filter
 
-        tarstream = dash_open(args.tarfile, 'rb')
-        tarstream_close = args.tarfile != '-'
+        tarstream = dash_open(args.tarfile, "rb")
+        tarstream_close = args.tarfile != "-"
 
         with create_filter_process(filter, stream=tarstream, stream_close=tarstream_close, inbound=True) as _stream:
             self._import_tar(args, repository, manifest, key, cache, _stream)
@@ -1882,46 +2185,66 @@ class Archiver:
         t0 = datetime.utcnow()
         t0_monotonic = time.monotonic()
 
-        archive = Archive(repository, key, manifest, args.name, cache=cache,
-                          create=True, checkpoint_interval=args.checkpoint_interval,
-                          progress=args.progress,
-                          chunker_params=args.chunker_params, start=t0, start_monotonic=t0_monotonic,
-                          log_json=args.log_json)
-        cp = ChunksProcessor(cache=cache, key=key,
-                             add_item=archive.add_item, write_checkpoint=archive.write_checkpoint,
-                             checkpoint_interval=args.checkpoint_interval, rechunkify=False)
-        tfo = TarfileObjectProcessors(cache=cache, key=key,
-                                      process_file_chunks=cp.process_file_chunks, add_item=archive.add_item,
-                                      chunker_params=args.chunker_params, show_progress=args.progress,
-                                      log_json=args.log_json, iec=args.iec,
-                                      file_status_printer=self.print_file_status)
+        archive = Archive(
+            repository,
+            key,
+            manifest,
+            args.name,
+            cache=cache,
+            create=True,
+            checkpoint_interval=args.checkpoint_interval,
+            progress=args.progress,
+            chunker_params=args.chunker_params,
+            start=t0,
+            start_monotonic=t0_monotonic,
+            log_json=args.log_json,
+        )
+        cp = ChunksProcessor(
+            cache=cache,
+            key=key,
+            add_item=archive.add_item,
+            write_checkpoint=archive.write_checkpoint,
+            checkpoint_interval=args.checkpoint_interval,
+            rechunkify=False,
+        )
+        tfo = TarfileObjectProcessors(
+            cache=cache,
+            key=key,
+            process_file_chunks=cp.process_file_chunks,
+            add_item=archive.add_item,
+            chunker_params=args.chunker_params,
+            show_progress=args.progress,
+            log_json=args.log_json,
+            iec=args.iec,
+            file_status_printer=self.print_file_status,
+        )
 
-        tar = tarfile.open(fileobj=tarstream, mode='r|')
+        tar = tarfile.open(fileobj=tarstream, mode="r|")
 
         while True:
             tarinfo = tar.next()
             if not tarinfo:
                 break
             if tarinfo.isreg():
-                status = tfo.process_file(tarinfo=tarinfo, status='A', type=stat.S_IFREG, tar=tar)
+                status = tfo.process_file(tarinfo=tarinfo, status="A", type=stat.S_IFREG, tar=tar)
                 archive.stats.nfiles += 1
             elif tarinfo.isdir():
-                status = tfo.process_dir(tarinfo=tarinfo, status='d', type=stat.S_IFDIR)
+                status = tfo.process_dir(tarinfo=tarinfo, status="d", type=stat.S_IFDIR)
             elif tarinfo.issym():
-                status = tfo.process_symlink(tarinfo=tarinfo, status='s', type=stat.S_IFLNK)
+                status = tfo.process_symlink(tarinfo=tarinfo, status="s", type=stat.S_IFLNK)
             elif tarinfo.islnk():
                 # tar uses a hardlink model like: the first instance of a hardlink is stored as a regular file,
                 # later instances are special entries referencing back to the first instance.
-                status = tfo.process_hardlink(tarinfo=tarinfo, status='h', type=stat.S_IFREG)
+                status = tfo.process_hardlink(tarinfo=tarinfo, status="h", type=stat.S_IFREG)
             elif tarinfo.isblk():
-                status = tfo.process_dev(tarinfo=tarinfo, status='b', type=stat.S_IFBLK)
+                status = tfo.process_dev(tarinfo=tarinfo, status="b", type=stat.S_IFBLK)
             elif tarinfo.ischr():
-                status = tfo.process_dev(tarinfo=tarinfo, status='c', type=stat.S_IFCHR)
+                status = tfo.process_dev(tarinfo=tarinfo, status="c", type=stat.S_IFCHR)
             elif tarinfo.isfifo():
-                status = tfo.process_fifo(tarinfo=tarinfo, status='f', type=stat.S_IFIFO)
+                status = tfo.process_fifo(tarinfo=tarinfo, status="f", type=stat.S_IFIFO)
             else:
-                status = 'E'
-                self.print_warning('%s: Unsupported tarinfo type %s', tarinfo.name, tarinfo.type)
+                status = "E"
+                self.print_warning("%s: Unsupported tarinfo type %s", tarinfo.name, tarinfo.type)
             self.print_file_status(status, tarinfo.name)
 
         # This does not close the fileobj (tarstream) we passed to it -- a side effect of the | mode.
@@ -1934,13 +2257,9 @@ class Archiver:
         args.stats |= args.json
         if args.stats:
             if args.json:
-                json_print(basic_json_data(archive.manifest, cache=archive.cache, extra={
-                    'archive': archive,
-                }))
+                json_print(basic_json_data(archive.manifest, cache=archive.cache, extra={"archive": archive}))
             else:
-                log_multi(str(archive),
-                          str(archive.stats),
-                          logger=logging.getLogger('borg.output.stats'))
+                log_multi(str(archive), str(archive.stats), logger=logging.getLogger("borg.output.stats"))
 
     @with_repository(manifest=False, exclusive=True)
     def do_with_lock(self, args, repository):
@@ -1957,7 +2276,7 @@ class Archiver:
         # usually, a 0 byte (open for writing) segment file would be visible in the filesystem here.
         # we write and close this file, to rather have a valid segment file on disk, before invoking the subprocess.
         # we can only do this for local repositories (with .io), though:
-        if hasattr(repository, 'io'):
+        if hasattr(repository, "io"):
             repository.io.close_segment()
         env = prepare_subprocess_env(system=True)
         try:
@@ -1987,81 +2306,87 @@ class Archiver:
         """get, set, and delete values in a repository or cache config file"""
 
         def repo_validate(section, name, value=None, check_value=True):
-            if section not in ['repository', ]:
-                raise ValueError('Invalid section')
-            if name in ['segments_per_dir', 'last_segment_checked', ]:
+            if section not in ["repository"]:
+                raise ValueError("Invalid section")
+            if name in ["segments_per_dir", "last_segment_checked"]:
                 if check_value:
                     try:
                         int(value)
                     except ValueError:
-                        raise ValueError('Invalid value') from None
-            elif name in ['max_segment_size', 'additional_free_space', 'storage_quota', ]:
+                        raise ValueError("Invalid value") from None
+            elif name in ["max_segment_size", "additional_free_space", "storage_quota"]:
                 if check_value:
                     try:
                         parse_file_size(value)
                     except ValueError:
-                        raise ValueError('Invalid value') from None
-                    if name == 'storage_quota':
-                        if parse_file_size(value) < parse_file_size('10M'):
-                            raise ValueError('Invalid value: storage_quota < 10M')
-                    elif name == 'max_segment_size':
+                        raise ValueError("Invalid value") from None
+                    if name == "storage_quota":
+                        if parse_file_size(value) < parse_file_size("10M"):
+                            raise ValueError("Invalid value: storage_quota < 10M")
+                    elif name == "max_segment_size":
                         if parse_file_size(value) >= MAX_SEGMENT_SIZE_LIMIT:
-                            raise ValueError('Invalid value: max_segment_size >= %d' % MAX_SEGMENT_SIZE_LIMIT)
-            elif name in ['append_only', ]:
-                if check_value and value not in ['0', '1']:
-                    raise ValueError('Invalid value')
-            elif name in ['id', ]:
+                            raise ValueError("Invalid value: max_segment_size >= %d" % MAX_SEGMENT_SIZE_LIMIT)
+            elif name in ["append_only"]:
+                if check_value and value not in ["0", "1"]:
+                    raise ValueError("Invalid value")
+            elif name in ["id"]:
                 if check_value:
                     try:
                         bin_id = unhexlify(value)
                     except:
-                        raise ValueError('Invalid value, must be 64 hex digits') from None
+                        raise ValueError("Invalid value, must be 64 hex digits") from None
                     if len(bin_id) != 32:
-                        raise ValueError('Invalid value, must be 64 hex digits')
+                        raise ValueError("Invalid value, must be 64 hex digits")
             else:
-                raise ValueError('Invalid name')
+                raise ValueError("Invalid name")
 
         def cache_validate(section, name, value=None, check_value=True):
-            if section not in ['cache', ]:
-                raise ValueError('Invalid section')
-            if name in ['previous_location', ]:
+            if section not in ["cache"]:
+                raise ValueError("Invalid section")
+            if name in ["previous_location"]:
                 if check_value:
                     Location(value)
             else:
-                raise ValueError('Invalid name')
+                raise ValueError("Invalid name")
 
         def list_config(config):
             default_values = {
-                'version': '1',
-                'segments_per_dir': str(DEFAULT_SEGMENTS_PER_DIR),
-                'max_segment_size': str(MAX_SEGMENT_SIZE_LIMIT),
-                'additional_free_space': '0',
-                'storage_quota': repository.storage_quota,
-                'append_only': repository.append_only
+                "version": "1",
+                "segments_per_dir": str(DEFAULT_SEGMENTS_PER_DIR),
+                "max_segment_size": str(MAX_SEGMENT_SIZE_LIMIT),
+                "additional_free_space": "0",
+                "storage_quota": repository.storage_quota,
+                "append_only": repository.append_only,
             }
-            print('[repository]')
-            for key in ['version', 'segments_per_dir', 'max_segment_size',
-                        'storage_quota', 'additional_free_space', 'append_only',
-                        'id']:
-                value = config.get('repository', key, fallback=False)
+            print("[repository]")
+            for key in [
+                "version",
+                "segments_per_dir",
+                "max_segment_size",
+                "storage_quota",
+                "additional_free_space",
+                "append_only",
+                "id",
+            ]:
+                value = config.get("repository", key, fallback=False)
                 if value is None:
                     value = default_values.get(key)
                     if value is None:
-                        raise Error('The repository config is missing the %s key which has no default value' % key)
-                print(f'{key} = {value}')
-            for key in ['last_segment_checked', ]:
-                value = config.get('repository', key, fallback=None)
+                        raise Error("The repository config is missing the %s key which has no default value" % key)
+                print(f"{key} = {value}")
+            for key in ["last_segment_checked"]:
+                value = config.get("repository", key, fallback=None)
                 if value is None:
                     continue
-                print(f'{key} = {value}')
+                print(f"{key} = {value}")
 
         if not args.list:
             if args.name is None:
-                self.print_error('No config key name was provided.')
+                self.print_error("No config key name was provided.")
                 return self.exit_code
 
             try:
-                section, name = args.name.split('.')
+                section, name = args.name.split(".")
             except ValueError:
                 section = args.cache and "cache" or "repository"
                 name = args.name
@@ -2112,22 +2437,21 @@ class Archiver:
         print(sysinfo())
 
         # Additional debug information
-        print('CRC implementation:', crc32.__name__)
-        print('Process ID:', get_process_id())
+        print("CRC implementation:", crc32.__name__)
+        print("Process ID:", get_process_id())
         return EXIT_SUCCESS
 
     @with_repository(compatibility=Manifest.NO_OPERATION_CHECK)
     def do_debug_dump_archive_items(self, args, repository, manifest, key):
         """dump (decrypted, decompressed) archive items metadata (not: data)"""
-        archive = Archive(repository, key, manifest, args.name,
-                          consider_part_files=args.consider_part_files)
+        archive = Archive(repository, key, manifest, args.name, consider_part_files=args.consider_part_files)
         for i, item_id in enumerate(archive.metadata.items):
             data = key.decrypt(item_id, repository.get(item_id))
-            filename = '%06d_%s.items' % (i, bin_to_hex(item_id))
-            print('Dumping', filename)
-            with open(filename, 'wb') as fd:
+            filename = "%06d_%s.items" % (i, bin_to_hex(item_id))
+            print("Dumping", filename)
+            with open(filename, "wb") as fd:
                 fd.write(data)
-        print('Done.')
+        print("Done.")
         return EXIT_SUCCESS
 
     @with_repository(compatibility=Manifest.NO_OPERATION_CHECK)
@@ -2142,27 +2466,27 @@ class Archiver:
         indent = 4
 
         def do_indent(d):
-            return textwrap.indent(json.dumps(d, indent=indent), prefix=' ' * indent)
+            return textwrap.indent(json.dumps(d, indent=indent), prefix=" " * indent)
 
         def output(fd):
             # this outputs megabytes of data for a modest sized archive, so some manual streaming json output
-            fd.write('{\n')
+            fd.write("{\n")
             fd.write('    "_name": ' + json.dumps(args.name) + ",\n")
             fd.write('    "_manifest_entry":\n')
             fd.write(do_indent(prepare_dump_dict(archive_meta_orig)))
-            fd.write(',\n')
+            fd.write(",\n")
 
-            data = key.decrypt(archive_meta_orig['id'], repository.get(archive_meta_orig['id']))
+            data = key.decrypt(archive_meta_orig["id"], repository.get(archive_meta_orig["id"]))
             archive_org_dict = msgpack.unpackb(data, object_hook=StableDict)
 
             fd.write('    "_meta":\n')
             fd.write(do_indent(prepare_dump_dict(archive_org_dict)))
-            fd.write(',\n')
+            fd.write(",\n")
             fd.write('    "_items": [\n')
 
             unpacker = msgpack.Unpacker(use_list=False, object_hook=StableDict)
             first = True
-            for item_id in archive_org_dict['items']:
+            for item_id in archive_org_dict["items"]:
                 data = key.decrypt(item_id, repository.get(item_id))
                 unpacker.feed(data)
                 for item in unpacker:
@@ -2170,13 +2494,13 @@ class Archiver:
                     if first:
                         first = False
                     else:
-                        fd.write(',\n')
+                        fd.write(",\n")
                     fd.write(do_indent(item))
 
-            fd.write('\n')
-            fd.write('    ]\n}\n')
+            fd.write("\n")
+            fd.write("    ]\n}\n")
 
-        with dash_open(args.path, 'w') as fd:
+        with dash_open(args.path, "w") as fd:
             output(fd)
         return EXIT_SUCCESS
 
@@ -2188,7 +2512,7 @@ class Archiver:
 
         meta = prepare_dump_dict(msgpack.unpackb(data, object_hook=StableDict))
 
-        with dash_open(args.path, 'w') as fd:
+        with dash_open(args.path, "w") as fd:
             json.dump(meta, fd, indent=4)
         return EXIT_SUCCESS
 
@@ -2201,14 +2525,14 @@ class Archiver:
             if cdata is not None:
                 data = key.decrypt(id, cdata)
             else:
-                data = b''
-            tag_str = '' if tag is None else '_' + tag
-            segment_str = '_' + str(segment) if segment is not None else ''
-            offset_str = '_' + str(offset) if offset is not None else ''
-            id_str = '_' + bin_to_hex(id) if id is not None else ''
-            filename = '%08d%s%s%s%s.obj' % (i, segment_str, offset_str, tag_str, id_str)
-            print('Dumping', filename)
-            with open(filename, 'wb') as fd:
+                data = b""
+            tag_str = "" if tag is None else "_" + tag
+            segment_str = "_" + str(segment) if segment is not None else ""
+            offset_str = "_" + str(offset) if offset is not None else ""
+            id_str = "_" + bin_to_hex(id) if id is not None else ""
+            filename = "%08d%s%s%s%s.obj" % (i, segment_str, offset_str, tag_str, id_str)
+            print("Dumping", filename)
+            with open(filename, "wb") as fd:
                 fd.write(data)
 
         if args.ghost:
@@ -2222,11 +2546,11 @@ class Archiver:
             i = 0
             for id, cdata, tag, segment, offset in repository.scan_low_level(segment=args.segment, offset=args.offset):
                 if tag == TAG_PUT:
-                    decrypt_dump(i, id, cdata, tag='put', segment=segment, offset=offset)
+                    decrypt_dump(i, id, cdata, tag="put", segment=segment, offset=offset)
                 elif tag == TAG_DELETE:
-                    decrypt_dump(i, id, None, tag='del', segment=segment, offset=offset)
+                    decrypt_dump(i, id, None, tag="del", segment=segment, offset=offset)
                 elif tag == TAG_COMMIT:
-                    decrypt_dump(i, None, None, tag='commit', segment=segment, offset=offset)
+                    decrypt_dump(i, None, None, tag="commit", segment=segment, offset=offset)
                 i += 1
         else:
             # set up the key without depending on a manifest obj
@@ -2244,7 +2568,7 @@ class Archiver:
                     cdata = repository.get(id)
                     decrypt_dump(i, id, cdata)
                     i += 1
-        print('Done.')
+        print("Done.")
         return EXIT_SUCCESS
 
     @with_repository(manifest=False)
@@ -2253,33 +2577,37 @@ class Archiver:
         context = 32
 
         def print_finding(info, wanted, data, offset):
-            before = data[offset - context:offset]
-            after = data[offset + len(wanted):offset + len(wanted) + context]
-            print('{}: {} {} {} == {!r} {!r} {!r}'.format(info, before.hex(), wanted.hex(), after.hex(),
-                                                          before, wanted, after))
+            before = data[offset - context : offset]
+            after = data[offset + len(wanted) : offset + len(wanted) + context]
+            print(
+                "{}: {} {} {} == {!r} {!r} {!r}".format(
+                    info, before.hex(), wanted.hex(), after.hex(), before, wanted, after
+                )
+            )
 
         wanted = args.wanted
         try:
-            if wanted.startswith('hex:'):
+            if wanted.startswith("hex:"):
                 wanted = unhexlify(wanted[4:])
-            elif wanted.startswith('str:'):
+            elif wanted.startswith("str:"):
                 wanted = wanted[4:].encode()
             else:
-                raise ValueError('unsupported search term')
+                raise ValueError("unsupported search term")
         except (ValueError, UnicodeEncodeError):
             wanted = None
         if not wanted:
-            self.print_error('search term needs to be hex:123abc or str:foobar style')
+            self.print_error("search term needs to be hex:123abc or str:foobar style")
             return EXIT_ERROR
 
         from .crypto.key import key_factory
+
         # set up the key without depending on a manifest obj
         ids = repository.list(limit=1, marker=None)
         cdata = repository.get(ids[0])
         key = key_factory(repository, cdata)
 
         marker = None
-        last_data = b''
+        last_data = b""
         last_id = None
         i = 0
         while True:
@@ -2292,11 +2620,11 @@ class Archiver:
                 data = key.decrypt(id, cdata)
 
                 # try to locate wanted sequence crossing the border of last_data and data
-                boundary_data = last_data[-(len(wanted) - 1):] + data[:len(wanted) - 1]
+                boundary_data = last_data[-(len(wanted) - 1) :] + data[: len(wanted) - 1]
                 if wanted in boundary_data:
-                    boundary_data = last_data[-(len(wanted) - 1 + context):] + data[:len(wanted) - 1 + context]
+                    boundary_data = last_data[-(len(wanted) - 1 + context) :] + data[: len(wanted) - 1 + context]
                     offset = boundary_data.find(wanted)
-                    info = '%d %s | %s' % (i, last_id.hex(), id.hex())
+                    info = "%d %s | %s" % (i, last_id.hex(), id.hex())
                     print_finding(info, wanted, boundary_data, offset)
 
                 # try to locate wanted sequence in data
@@ -2309,8 +2637,8 @@ class Archiver:
                 last_id, last_data = id, data
                 i += 1
                 if i % 10000 == 0:
-                    print('%d objects processed.' % i)
-        print('Done.')
+                    print("%d objects processed." % i)
+        print("Done.")
         return EXIT_SUCCESS
 
     @with_repository(manifest=False)
@@ -2362,7 +2690,7 @@ class Archiver:
                     print("object %s not found." % hex_id)
         if modified:
             repository.commit(compact=False)
-        print('Done.')
+        print("Done.")
         return EXIT_SUCCESS
 
     @with_repository(manifest=False, exclusive=True, cache=True, compatibility=Manifest.NO_OPERATION_CHECK)
@@ -2391,9 +2719,9 @@ class Archiver:
                 segments=repository.segments,
                 compact=repository.compact,
                 storage_quota_use=repository.storage_quota_use,
-                shadow_index={hexlify(k).decode(): v for k, v in repository.shadow_index.items()}
+                shadow_index={hexlify(k).decode(): v for k, v in repository.shadow_index.items()},
             )
-            with dash_open(args.path, 'w') as fd:
+            with dash_open(args.path, "w") as fd:
                 json.dump(hints, fd, indent=4)
         finally:
             repository.rollback()
@@ -2402,6 +2730,7 @@ class Archiver:
     def do_debug_convert_profile(self, args):
         """convert Borg profile to Python profile"""
         import marshal
+
         with args.output, args.input:
             marshal.dump(msgpack.unpack(args.input, use_list=False, raw=False), args.output)
         return EXIT_SUCCESS
@@ -2414,7 +2743,8 @@ class Archiver:
         return self.exit_code
 
     helptext = collections.OrderedDict()
-    helptext['patterns'] = textwrap.dedent('''
+    helptext["patterns"] = textwrap.dedent(
+        """
         When specifying one or more file paths in a Borg command that supports
         patterns for the respective option or argument, you can apply the
         patterns described here to include only desired files and/or exclude
@@ -2647,8 +2977,10 @@ class Archiver:
             - home/bobby/junk
 
         This allows you to share the same patterns between multiple repositories
-        without needing to specify them on the command line.\n\n''')
-    helptext['placeholders'] = textwrap.dedent('''
+        without needing to specify them on the command line.\n\n"""
+    )
+    helptext["placeholders"] = textwrap.dedent(
+        """
         Repository URLs, ``--name``, ``-a`` / ``--glob-archives``, ``--comment``
         and ``--remote-path`` values support these placeholders:
 
@@ -2705,8 +3037,10 @@ class Archiver:
             especially when using the now/utcnow placeholders, since systemd performs its own
             %-based variable replacement even in quoted text. To avoid interference from systemd,
             double all percent signs (``{hostname}-{now:%Y-%m-%d_%H:%M:%S}``
-            becomes ``{hostname}-{now:%%Y-%%m-%%d_%%H:%%M:%%S}``).\n\n''')
-    helptext['compression'] = textwrap.dedent('''
+            becomes ``{hostname}-{now:%%Y-%%m-%%d_%%H:%%M:%%S}``).\n\n"""
+    )
+    helptext["compression"] = textwrap.dedent(
+        """
         It is no problem to mix different compression methods in one repo,
         deduplication is done on the source data chunks (not on the compressed
         or encrypted data).
@@ -2791,7 +3125,8 @@ class Archiver:
             borg create --compression auto,lzma ...
             borg create --compression obfuscate,3,none ...
             borg create --compression obfuscate,3,auto,zstd,10 ...
-            borg create --compression obfuscate,2,zstd,6 ...\n\n''')
+            borg create --compression obfuscate,2,zstd,6 ...\n\n"""
+    )
 
     def do_help(self, parser, commands, args):
         if not args.topic:
@@ -2808,11 +3143,11 @@ class Archiver:
                 commands[args.topic].print_help()
         else:
             msg_lines = []
-            msg_lines += ['No help available on %s.' % args.topic]
-            msg_lines += ['Try one of the following:']
-            msg_lines += ['    Commands: %s' % ', '.join(sorted(commands.keys()))]
-            msg_lines += ['    Topics: %s' % ', '.join(sorted(self.helptext.keys()))]
-            parser.error('\n'.join(msg_lines))
+            msg_lines += ["No help available on %s." % args.topic]
+            msg_lines += ["Try one of the following:"]
+            msg_lines += ["    Commands: %s" % ", ".join(sorted(commands.keys()))]
+            msg_lines += ["    Topics: %s" % ", ".join(sorted(self.helptext.keys()))]
+            parser.error("\n".join(msg_lines))
         return self.exit_code
 
     def do_subcommand_help(self, parser, args):
@@ -2894,29 +3229,31 @@ class Archiver:
             assert suffix in self.suffix_precedence
 
             def add_argument(*args, **kwargs):
-                if 'dest' in kwargs:
-                    kwargs.setdefault('action', 'store')
-                    assert kwargs['action'] in ('help', 'store_const', 'store_true', 'store_false', 'store', 'append')
-                    is_append = kwargs['action'] == 'append'
+                if "dest" in kwargs:
+                    kwargs.setdefault("action", "store")
+                    assert kwargs["action"] in ("help", "store_const", "store_true", "store_false", "store", "append")
+                    is_append = kwargs["action"] == "append"
                     if is_append:
-                        self.append_options.add(kwargs['dest'])
-                        assert kwargs['default'] == [], 'The default is explicitly constructed as an empty list in resolve()'
+                        self.append_options.add(kwargs["dest"])
+                        assert (
+                            kwargs["default"] == []
+                        ), "The default is explicitly constructed as an empty list in resolve()"
                     else:
-                        self.common_options.setdefault(suffix, set()).add(kwargs['dest'])
-                    kwargs['dest'] += suffix
+                        self.common_options.setdefault(suffix, set()).add(kwargs["dest"])
+                    kwargs["dest"] += suffix
                     if not provide_defaults:
                         # Interpolate help now, in case the %(default)d (or so) is mentioned,
                         # to avoid producing incorrect help output.
                         # Assumption: Interpolated output can safely be interpolated again,
                         # which should always be the case.
                         # Note: We control all inputs.
-                        kwargs['help'] = kwargs['help'] % kwargs
+                        kwargs["help"] = kwargs["help"] % kwargs
                         if not is_append:
-                            kwargs['default'] = self.default_sentinel
+                            kwargs["default"] = self.default_sentinel
 
                 common_group.add_argument(*args, **kwargs)
 
-            common_group = parser.add_argument_group('Common options')
+            common_group = parser.add_argument_group("Common options")
             self.define_common_options(add_argument)
 
         def resolve(self, args: argparse.Namespace):  # Namespace has "in" but otherwise is not like a dict.
@@ -2965,13 +3302,13 @@ class Archiver:
         # e.g. through "borg ... --help", define a substitution for the reference here.
         # It will replace the entire :ref:`foo` verbatim.
         rst_plain_text_references = {
-            'a_status_oddity': '"I am seeing ‘A’ (added) status for a unchanged file!?"',
-            'separate_compaction': '"Separate compaction"',
-            'list_item_flags': '"Item flags"',
-            'borg_patterns': '"borg help patterns"',
-            'borg_placeholders': '"borg help placeholders"',
-            'key_files': 'Internals -> Data structures and file formats -> Key files',
-            'borg_key_export': 'borg key export --help',
+            "a_status_oddity": '"I am seeing ‘A’ (added) status for a unchanged file!?"',
+            "separate_compaction": '"Separate compaction"',
+            "list_item_flags": '"Item flags"',
+            "borg_patterns": '"borg help patterns"',
+            "borg_placeholders": '"borg help placeholders"',
+            "key_files": "Internals -> Data structures and file formats -> Key files",
+            "borg_key_export": "borg key export --help",
         }
 
         def process_epilog(epilog):
@@ -2979,166 +3316,323 @@ class Archiver:
             try:
                 mode = borg.doc_mode
             except AttributeError:
-                mode = 'command-line'
-            if mode in ('command-line', 'build_usage'):
-                epilog = [line for line in epilog if not line.startswith('.. man')]
-            epilog = '\n'.join(epilog)
-            if mode == 'command-line':
+                mode = "command-line"
+            if mode in ("command-line", "build_usage"):
+                epilog = [line for line in epilog if not line.startswith(".. man")]
+            epilog = "\n".join(epilog)
+            if mode == "command-line":
                 epilog = rst_to_terminal(epilog, rst_plain_text_references)
             return epilog
 
         def define_common_options(add_common_option):
-            add_common_option('-h', '--help', action='help', help='show this help message and exit')
-            add_common_option('--critical', dest='log_level',
-                              action='store_const', const='critical', default='warning',
-                              help='work on log level CRITICAL')
-            add_common_option('--error', dest='log_level',
-                              action='store_const', const='error', default='warning',
-                              help='work on log level ERROR')
-            add_common_option('--warning', dest='log_level',
-                              action='store_const', const='warning', default='warning',
-                              help='work on log level WARNING (default)')
-            add_common_option('--info', '-v', '--verbose', dest='log_level',
-                              action='store_const', const='info', default='warning',
-                              help='work on log level INFO')
-            add_common_option('--debug', dest='log_level',
-                              action='store_const', const='debug', default='warning',
-                              help='enable debug output, work on log level DEBUG')
-            add_common_option('--debug-topic', metavar='TOPIC', dest='debug_topics', action='append', default=[],
-                              help='enable TOPIC debugging (can be specified multiple times). '
-                                   'The logger path is borg.debug.<TOPIC> if TOPIC is not fully qualified.')
-            add_common_option('-p', '--progress', dest='progress', action='store_true',
-                              help='show progress information')
-            add_common_option('--iec', dest='iec', action='store_true',
-                              help='format using IEC units (1KiB = 1024B)')
-            add_common_option('--log-json', dest='log_json', action='store_true',
-                              help='Output one JSON object per log line instead of formatted text.')
-            add_common_option('--lock-wait', metavar='SECONDS', dest='lock_wait', type=int, default=1,
-                              help='wait at most SECONDS for acquiring a repository/cache lock (default: %(default)d).')
-            add_common_option('--bypass-lock', dest='lock', action='store_false',
-                              default=argparse.SUPPRESS,  # only create args attribute if option is specified
-                              help='Bypass locking mechanism')
-            add_common_option('--show-version', dest='show_version', action='store_true',
-                              help='show/log the borg version')
-            add_common_option('--show-rc', dest='show_rc', action='store_true',
-                              help='show/log the return code (rc)')
-            add_common_option('--umask', metavar='M', dest='umask', type=lambda s: int(s, 8), default=UMASK_DEFAULT,
-                              help='set umask to M (local only, default: %(default)04o)')
-            add_common_option('--remote-path', metavar='PATH', dest='remote_path',
-                              help='use PATH as borg executable on the remote (default: "borg")')
-            add_common_option('--upload-ratelimit', metavar='RATE', dest='upload_ratelimit', type=int,
-                              help='set network upload rate limit in kiByte/s (default: 0=unlimited)')
-            add_common_option('--upload-buffer', metavar='UPLOAD_BUFFER', dest='upload_buffer', type=int,
-                              help='set network upload buffer size in MiB. (default: 0=no buffer)')
-            add_common_option('--consider-part-files', dest='consider_part_files', action='store_true',
-                              help='treat part files like normal files (e.g. to list/extract them)')
-            add_common_option('--debug-profile', metavar='FILE', dest='debug_profile', default=None,
-                              help='Write execution profile in Borg format into FILE. For local use a Python-'
-                                   'compatible file can be generated by suffixing FILE with ".pyprof".')
-            add_common_option('--rsh', metavar='RSH', dest='rsh',
-                              help="Use this command to connect to the 'borg serve' process (default: 'ssh')")
-            add_common_option('-r', '--repo', metavar='REPO', dest='location',
-                              type=location_validator(other=False), default=Location(other=False),
-                              help="repository to use")
+            add_common_option("-h", "--help", action="help", help="show this help message and exit")
+            add_common_option(
+                "--critical",
+                dest="log_level",
+                action="store_const",
+                const="critical",
+                default="warning",
+                help="work on log level CRITICAL",
+            )
+            add_common_option(
+                "--error",
+                dest="log_level",
+                action="store_const",
+                const="error",
+                default="warning",
+                help="work on log level ERROR",
+            )
+            add_common_option(
+                "--warning",
+                dest="log_level",
+                action="store_const",
+                const="warning",
+                default="warning",
+                help="work on log level WARNING (default)",
+            )
+            add_common_option(
+                "--info",
+                "-v",
+                "--verbose",
+                dest="log_level",
+                action="store_const",
+                const="info",
+                default="warning",
+                help="work on log level INFO",
+            )
+            add_common_option(
+                "--debug",
+                dest="log_level",
+                action="store_const",
+                const="debug",
+                default="warning",
+                help="enable debug output, work on log level DEBUG",
+            )
+            add_common_option(
+                "--debug-topic",
+                metavar="TOPIC",
+                dest="debug_topics",
+                action="append",
+                default=[],
+                help="enable TOPIC debugging (can be specified multiple times). "
+                "The logger path is borg.debug.<TOPIC> if TOPIC is not fully qualified.",
+            )
+            add_common_option(
+                "-p", "--progress", dest="progress", action="store_true", help="show progress information"
+            )
+            add_common_option("--iec", dest="iec", action="store_true", help="format using IEC units (1KiB = 1024B)")
+            add_common_option(
+                "--log-json",
+                dest="log_json",
+                action="store_true",
+                help="Output one JSON object per log line instead of formatted text.",
+            )
+            add_common_option(
+                "--lock-wait",
+                metavar="SECONDS",
+                dest="lock_wait",
+                type=int,
+                default=1,
+                help="wait at most SECONDS for acquiring a repository/cache lock (default: %(default)d).",
+            )
+            add_common_option(
+                "--bypass-lock",
+                dest="lock",
+                action="store_false",
+                default=argparse.SUPPRESS,  # only create args attribute if option is specified
+                help="Bypass locking mechanism",
+            )
+            add_common_option(
+                "--show-version", dest="show_version", action="store_true", help="show/log the borg version"
+            )
+            add_common_option("--show-rc", dest="show_rc", action="store_true", help="show/log the return code (rc)")
+            add_common_option(
+                "--umask",
+                metavar="M",
+                dest="umask",
+                type=lambda s: int(s, 8),
+                default=UMASK_DEFAULT,
+                help="set umask to M (local only, default: %(default)04o)",
+            )
+            add_common_option(
+                "--remote-path",
+                metavar="PATH",
+                dest="remote_path",
+                help='use PATH as borg executable on the remote (default: "borg")',
+            )
+            add_common_option(
+                "--upload-ratelimit",
+                metavar="RATE",
+                dest="upload_ratelimit",
+                type=int,
+                help="set network upload rate limit in kiByte/s (default: 0=unlimited)",
+            )
+            add_common_option(
+                "--upload-buffer",
+                metavar="UPLOAD_BUFFER",
+                dest="upload_buffer",
+                type=int,
+                help="set network upload buffer size in MiB. (default: 0=no buffer)",
+            )
+            add_common_option(
+                "--consider-part-files",
+                dest="consider_part_files",
+                action="store_true",
+                help="treat part files like normal files (e.g. to list/extract them)",
+            )
+            add_common_option(
+                "--debug-profile",
+                metavar="FILE",
+                dest="debug_profile",
+                default=None,
+                help="Write execution profile in Borg format into FILE. For local use a Python-"
+                'compatible file can be generated by suffixing FILE with ".pyprof".',
+            )
+            add_common_option(
+                "--rsh",
+                metavar="RSH",
+                dest="rsh",
+                help="Use this command to connect to the 'borg serve' process (default: 'ssh')",
+            )
+            add_common_option(
+                "-r",
+                "--repo",
+                metavar="REPO",
+                dest="location",
+                type=location_validator(other=False),
+                default=Location(other=False),
+                help="repository to use",
+            )
 
         def define_exclude_and_patterns(add_option, *, tag_files=False, strip_components=False):
-            add_option('-e', '--exclude', metavar='PATTERN', dest='patterns',
-                       type=parse_exclude_pattern, action='append',
-                       help='exclude paths matching PATTERN')
-            add_option('--exclude-from', metavar='EXCLUDEFILE', action=ArgparseExcludeFileAction,
-                       help='read exclude patterns from EXCLUDEFILE, one per line')
-            add_option('--pattern', metavar='PATTERN', action=ArgparsePatternAction,
-                       help='include/exclude paths matching PATTERN')
-            add_option('--patterns-from', metavar='PATTERNFILE', action=ArgparsePatternFileAction,
-                       help='read include/exclude patterns from PATTERNFILE, one per line')
+            add_option(
+                "-e",
+                "--exclude",
+                metavar="PATTERN",
+                dest="patterns",
+                type=parse_exclude_pattern,
+                action="append",
+                help="exclude paths matching PATTERN",
+            )
+            add_option(
+                "--exclude-from",
+                metavar="EXCLUDEFILE",
+                action=ArgparseExcludeFileAction,
+                help="read exclude patterns from EXCLUDEFILE, one per line",
+            )
+            add_option(
+                "--pattern",
+                metavar="PATTERN",
+                action=ArgparsePatternAction,
+                help="include/exclude paths matching PATTERN",
+            )
+            add_option(
+                "--patterns-from",
+                metavar="PATTERNFILE",
+                action=ArgparsePatternFileAction,
+                help="read include/exclude patterns from PATTERNFILE, one per line",
+            )
 
             if tag_files:
-                add_option('--exclude-caches', dest='exclude_caches', action='store_true',
-                           help='exclude directories that contain a CACHEDIR.TAG file '
-                                '(http://www.bford.info/cachedir/spec.html)')
-                add_option('--exclude-if-present', metavar='NAME', dest='exclude_if_present',
-                           action='append', type=str,
-                           help='exclude directories that are tagged by containing a filesystem object with '
-                                'the given NAME')
-                add_option('--keep-exclude-tags', dest='keep_exclude_tags',
-                           action='store_true',
-                           help='if tag objects are specified with ``--exclude-if-present``, '
-                                'don\'t omit the tag objects themselves from the backup archive')
+                add_option(
+                    "--exclude-caches",
+                    dest="exclude_caches",
+                    action="store_true",
+                    help="exclude directories that contain a CACHEDIR.TAG file "
+                    "(http://www.bford.info/cachedir/spec.html)",
+                )
+                add_option(
+                    "--exclude-if-present",
+                    metavar="NAME",
+                    dest="exclude_if_present",
+                    action="append",
+                    type=str,
+                    help="exclude directories that are tagged by containing a filesystem object with " "the given NAME",
+                )
+                add_option(
+                    "--keep-exclude-tags",
+                    dest="keep_exclude_tags",
+                    action="store_true",
+                    help="if tag objects are specified with ``--exclude-if-present``, "
+                    "don't omit the tag objects themselves from the backup archive",
+                )
 
             if strip_components:
-                add_option('--strip-components', metavar='NUMBER', dest='strip_components', type=int, default=0,
-                           help='Remove the specified number of leading path elements. '
-                                'Paths with fewer elements will be silently skipped.')
+                add_option(
+                    "--strip-components",
+                    metavar="NUMBER",
+                    dest="strip_components",
+                    type=int,
+                    default=0,
+                    help="Remove the specified number of leading path elements. "
+                    "Paths with fewer elements will be silently skipped.",
+                )
 
         def define_exclusion_group(subparser, **kwargs):
-            exclude_group = subparser.add_argument_group('Exclusion options')
+            exclude_group = subparser.add_argument_group("Exclusion options")
             define_exclude_and_patterns(exclude_group.add_argument, **kwargs)
             return exclude_group
 
         def define_archive_filters_group(subparser, *, sort_by=True, first_last=True):
-            filters_group = subparser.add_argument_group('Archive filters',
-                                                         'Archive filters can be applied to repository targets.')
+            filters_group = subparser.add_argument_group(
+                "Archive filters", "Archive filters can be applied to repository targets."
+            )
             group = filters_group.add_mutually_exclusive_group()
-            group.add_argument('-a', '--glob-archives', metavar='GLOB', dest='glob_archives',
-                               type=GlobSpec, action=Highlander,
-                               help='only consider archive names matching the glob. '
-                                    'sh: rules apply, see "borg help patterns".')
+            group.add_argument(
+                "-a",
+                "--glob-archives",
+                metavar="GLOB",
+                dest="glob_archives",
+                type=GlobSpec,
+                action=Highlander,
+                help="only consider archive names matching the glob. " 'sh: rules apply, see "borg help patterns".',
+            )
 
             if sort_by:
-                sort_by_default = 'timestamp'
-                filters_group.add_argument('--sort-by', metavar='KEYS', dest='sort_by',
-                                           type=SortBySpec, default=sort_by_default,
-                                           help='Comma-separated list of sorting keys; valid keys are: {}; default is: {}'
-                                           .format(', '.join(AI_HUMAN_SORT_KEYS), sort_by_default))
+                sort_by_default = "timestamp"
+                filters_group.add_argument(
+                    "--sort-by",
+                    metavar="KEYS",
+                    dest="sort_by",
+                    type=SortBySpec,
+                    default=sort_by_default,
+                    help="Comma-separated list of sorting keys; valid keys are: {}; default is: {}".format(
+                        ", ".join(AI_HUMAN_SORT_KEYS), sort_by_default
+                    ),
+                )
 
             if first_last:
                 group = filters_group.add_mutually_exclusive_group()
-                group.add_argument('--first', metavar='N', dest='first', default=0, type=positive_int_validator,
-                                   help='consider first N archives after other filters were applied')
-                group.add_argument('--last', metavar='N', dest='last', default=0, type=positive_int_validator,
-                                   help='consider last N archives after other filters were applied')
+                group.add_argument(
+                    "--first",
+                    metavar="N",
+                    dest="first",
+                    default=0,
+                    type=positive_int_validator,
+                    help="consider first N archives after other filters were applied",
+                )
+                group.add_argument(
+                    "--last",
+                    metavar="N",
+                    dest="last",
+                    default=0,
+                    type=positive_int_validator,
+                    help="consider last N archives after other filters were applied",
+                )
 
             return filters_group
 
         def define_borg_mount(parser):
             parser.set_defaults(func=self.do_mount)
-            parser.add_argument('--consider-checkpoints', action='store_true', dest='consider_checkpoints',
-                                help='Show checkpoint archives in the repository contents list (default: hidden).')
-            parser.add_argument('mountpoint', metavar='MOUNTPOINT', type=str,
-                                help='where to mount filesystem')
-            parser.add_argument('-f', '--foreground', dest='foreground',
-                                action='store_true',
-                                help='stay in foreground, do not daemonize')
-            parser.add_argument('-o', dest='options', type=str, action=Highlander,
-                                help='Extra mount options')
-            parser.add_argument('--numeric-ids', dest='numeric_ids', action='store_true',
-                                  help='use numeric user and group identifiers from archive(s)')
+            parser.add_argument(
+                "--consider-checkpoints",
+                action="store_true",
+                dest="consider_checkpoints",
+                help="Show checkpoint archives in the repository contents list (default: hidden).",
+            )
+            parser.add_argument("mountpoint", metavar="MOUNTPOINT", type=str, help="where to mount filesystem")
+            parser.add_argument(
+                "-f",
+                "--foreground",
+                dest="foreground",
+                action="store_true",
+                help="stay in foreground, do not daemonize",
+            )
+            parser.add_argument("-o", dest="options", type=str, action=Highlander, help="Extra mount options")
+            parser.add_argument(
+                "--numeric-ids",
+                dest="numeric_ids",
+                action="store_true",
+                help="use numeric user and group identifiers from archive(s)",
+            )
             define_archive_filters_group(parser)
-            parser.add_argument('paths', metavar='PATH', nargs='*', type=str,
-                                   help='paths to extract; patterns are supported')
+            parser.add_argument(
+                "paths", metavar="PATH", nargs="*", type=str, help="paths to extract; patterns are supported"
+            )
             define_exclusion_group(parser, strip_components=True)
 
-        parser = argparse.ArgumentParser(prog=self.prog, description='Borg - Deduplicated Backups',
-                                         add_help=False)
+        parser = argparse.ArgumentParser(prog=self.prog, description="Borg - Deduplicated Backups", add_help=False)
         # paths and patterns must have an empty list as default everywhere
-        parser.set_defaults(fallback2_func=functools.partial(self.do_maincommand_help, parser),
-                            paths=[], patterns=[])
-        parser.common_options = self.CommonOptions(define_common_options,
-                                                   suffix_precedence=('_maincommand', '_midcommand', '_subcommand'))
-        parser.add_argument('-V', '--version', action='version', version='%(prog)s ' + __version__,
-                            help='show version number and exit')
-        parser.common_options.add_common_group(parser, '_maincommand', provide_defaults=True)
+        parser.set_defaults(fallback2_func=functools.partial(self.do_maincommand_help, parser), paths=[], patterns=[])
+        parser.common_options = self.CommonOptions(
+            define_common_options, suffix_precedence=("_maincommand", "_midcommand", "_subcommand")
+        )
+        parser.add_argument(
+            "-V", "--version", action="version", version="%(prog)s " + __version__, help="show version number and exit"
+        )
+        parser.common_options.add_common_group(parser, "_maincommand", provide_defaults=True)
 
         common_parser = argparse.ArgumentParser(add_help=False, prog=self.prog)
         common_parser.set_defaults(paths=[], patterns=[])
-        parser.common_options.add_common_group(common_parser, '_subcommand')
+        parser.common_options.add_common_group(common_parser, "_subcommand")
 
         mid_common_parser = argparse.ArgumentParser(add_help=False, prog=self.prog)
         mid_common_parser.set_defaults(paths=[], patterns=[])
-        parser.common_options.add_common_group(mid_common_parser, '_midcommand')
+        parser.common_options.add_common_group(mid_common_parser, "_midcommand")
 
         # borg mount
-        mount_epilog = process_epilog("""
+        mount_epilog = process_epilog(
+            """
         This command mounts an archive as a FUSE filesystem. This can be useful
         for browsing an archive or restoring individual files. When restoring,
         take into account that the current FUSE implementation does not support
@@ -3195,31 +3689,37 @@ class Archiver:
 
         When running in the foreground ^C/SIGINT unmounts cleanly, but other
         signals or crashes do not.
-        """)
+        """
+        )
 
-        if parser.prog == 'borgfs':
+        if parser.prog == "borgfs":
             parser.description = self.do_mount.__doc__
             parser.epilog = mount_epilog
             parser.formatter_class = argparse.RawDescriptionHelpFormatter
-            parser.help = 'mount repository'
+            parser.help = "mount repository"
             define_borg_mount(parser)
             return parser
 
-        subparsers = parser.add_subparsers(title='required arguments', metavar='<command>')
+        subparsers = parser.add_subparsers(title="required arguments", metavar="<command>")
 
         # borg benchmark
         benchmark_epilog = process_epilog("These commands do various benchmarks.")
 
-        subparser = subparsers.add_parser('benchmark', parents=[mid_common_parser], add_help=False,
-                                          description='benchmark command',
-                                          epilog=benchmark_epilog,
-                                          formatter_class=argparse.RawDescriptionHelpFormatter,
-                                          help='benchmark command')
+        subparser = subparsers.add_parser(
+            "benchmark",
+            parents=[mid_common_parser],
+            add_help=False,
+            description="benchmark command",
+            epilog=benchmark_epilog,
+            formatter_class=argparse.RawDescriptionHelpFormatter,
+            help="benchmark command",
+        )
 
-        benchmark_parsers = subparser.add_subparsers(title='required arguments', metavar='<command>')
+        benchmark_parsers = subparser.add_subparsers(title="required arguments", metavar="<command>")
         subparser.set_defaults(fallback_func=functools.partial(self.do_subcommand_help, subparser))
 
-        bench_crud_epilog = process_epilog("""
+        bench_crud_epilog = process_epilog(
+            """
         This command benchmarks borg CRUD (create, read, update, delete) operations.
 
         It creates input data below the given PATH and backups this data into the given REPO.
@@ -3257,17 +3757,23 @@ class Archiver:
 
         Please note that there might be quite some variance in these measurements.
         Try multiple measurements and having a otherwise idle machine (and network, if you use it).
-        """)
-        subparser = benchmark_parsers.add_parser('crud', parents=[common_parser], add_help=False,
-                                                 description=self.do_benchmark_crud.__doc__,
-                                                 epilog=bench_crud_epilog,
-                                                 formatter_class=argparse.RawDescriptionHelpFormatter,
-                                                 help='benchmarks borg CRUD (create, extract, update, delete).')
+        """
+        )
+        subparser = benchmark_parsers.add_parser(
+            "crud",
+            parents=[common_parser],
+            add_help=False,
+            description=self.do_benchmark_crud.__doc__,
+            epilog=bench_crud_epilog,
+            formatter_class=argparse.RawDescriptionHelpFormatter,
+            help="benchmarks borg CRUD (create, extract, update, delete).",
+        )
         subparser.set_defaults(func=self.do_benchmark_crud)
 
-        subparser.add_argument('path', metavar='PATH', help='path were to create benchmark input data')
+        subparser.add_argument("path", metavar="PATH", help="path were to create benchmark input data")
 
-        bench_cpu_epilog = process_epilog("""
+        bench_cpu_epilog = process_epilog(
+            """
         This command benchmarks misc. CPU bound borg operations.
 
         It creates input data in memory, runs the operation and then displays throughput.
@@ -3275,29 +3781,41 @@ class Archiver:
 
         - an otherwise as idle as possible machine
         - enough free memory so there will be no slow down due to paging activity
-        """)
-        subparser = benchmark_parsers.add_parser('cpu', parents=[common_parser], add_help=False,
-                                                 description=self.do_benchmark_cpu.__doc__,
-                                                 epilog=bench_cpu_epilog,
-                                                 formatter_class=argparse.RawDescriptionHelpFormatter,
-                                                 help='benchmarks borg CPU bound operations.')
+        """
+        )
+        subparser = benchmark_parsers.add_parser(
+            "cpu",
+            parents=[common_parser],
+            add_help=False,
+            description=self.do_benchmark_cpu.__doc__,
+            epilog=bench_cpu_epilog,
+            formatter_class=argparse.RawDescriptionHelpFormatter,
+            help="benchmarks borg CPU bound operations.",
+        )
         subparser.set_defaults(func=self.do_benchmark_cpu)
 
         # borg break-lock
-        break_lock_epilog = process_epilog("""
+        break_lock_epilog = process_epilog(
+            """
         This command breaks the repository and cache locks.
         Please use carefully and only while no borg process (on any machine) is
         trying to access the Cache or the Repository.
-        """)
-        subparser = subparsers.add_parser('break-lock', parents=[common_parser], add_help=False,
-                                          description=self.do_break_lock.__doc__,
-                                          epilog=break_lock_epilog,
-                                          formatter_class=argparse.RawDescriptionHelpFormatter,
-                                          help='break repository and cache locks')
+        """
+        )
+        subparser = subparsers.add_parser(
+            "break-lock",
+            parents=[common_parser],
+            add_help=False,
+            description=self.do_break_lock.__doc__,
+            epilog=break_lock_epilog,
+            formatter_class=argparse.RawDescriptionHelpFormatter,
+            help="break repository and cache locks",
+        )
         subparser.set_defaults(func=self.do_break_lock)
 
         # borg check
-        check_epilog = process_epilog("""
+        check_epilog = process_epilog(
+            """
         The check command verifies the consistency of a repository and the corresponding archives.
 
         check --repair is a potentially dangerous function and might lead to data loss
@@ -3370,31 +3888,49 @@ class Archiver:
         which will detect (accidental) corruption. For encrypted repositories it is
         tamper-resistant as well, unless the attacker has access to the keys. It is also very
         slow.
-        """)
-        subparser = subparsers.add_parser('check', parents=[common_parser], add_help=False,
-                                          description=self.do_check.__doc__,
-                                          epilog=check_epilog,
-                                          formatter_class=argparse.RawDescriptionHelpFormatter,
-                                          help='verify repository')
+        """
+        )
+        subparser = subparsers.add_parser(
+            "check",
+            parents=[common_parser],
+            add_help=False,
+            description=self.do_check.__doc__,
+            epilog=check_epilog,
+            formatter_class=argparse.RawDescriptionHelpFormatter,
+            help="verify repository",
+        )
         subparser.set_defaults(func=self.do_check)
-        subparser.add_argument('--repository-only', dest='repo_only', action='store_true',
-                               help='only perform repository checks')
-        subparser.add_argument('--archives-only', dest='archives_only', action='store_true',
-                               help='only perform archives checks')
-        subparser.add_argument('--verify-data', dest='verify_data', action='store_true',
-                               help='perform cryptographic archive data integrity verification '
-                                    '(conflicts with ``--repository-only``)')
-        subparser.add_argument('--repair', dest='repair', action='store_true',
-                               help='attempt to repair any inconsistencies found')
-        subparser.add_argument('--save-space', dest='save_space', action='store_true',
-                               help='work slower, but using less space')
-        subparser.add_argument('--max-duration', metavar='SECONDS', dest='max_duration',
-                                   type=int, default=0,
-                                   help='do only a partial repo check for max. SECONDS seconds (Default: unlimited)')
+        subparser.add_argument(
+            "--repository-only", dest="repo_only", action="store_true", help="only perform repository checks"
+        )
+        subparser.add_argument(
+            "--archives-only", dest="archives_only", action="store_true", help="only perform archives checks"
+        )
+        subparser.add_argument(
+            "--verify-data",
+            dest="verify_data",
+            action="store_true",
+            help="perform cryptographic archive data integrity verification " "(conflicts with ``--repository-only``)",
+        )
+        subparser.add_argument(
+            "--repair", dest="repair", action="store_true", help="attempt to repair any inconsistencies found"
+        )
+        subparser.add_argument(
+            "--save-space", dest="save_space", action="store_true", help="work slower, but using less space"
+        )
+        subparser.add_argument(
+            "--max-duration",
+            metavar="SECONDS",
+            dest="max_duration",
+            type=int,
+            default=0,
+            help="do only a partial repo check for max. SECONDS seconds (Default: unlimited)",
+        )
         define_archive_filters_group(subparser)
 
         # borg compact
-        compact_epilog = process_epilog("""
+        compact_epilog = process_epilog(
+            """
         This command frees repository space by compacting segments.
 
         Use this regularly to avoid running out of space - you do not need to use this
@@ -3412,19 +3948,30 @@ class Archiver:
         When using ``--verbose``, borg will output an estimate of the freed space.
 
         See :ref:`separate_compaction` in Additional Notes for more details.
-        """)
-        subparser = subparsers.add_parser('compact', parents=[common_parser], add_help=False,
-                                          description=self.do_compact.__doc__,
-                                          epilog=compact_epilog,
-                                          formatter_class=argparse.RawDescriptionHelpFormatter,
-                                          help='compact segment files / free space in repo')
+        """
+        )
+        subparser = subparsers.add_parser(
+            "compact",
+            parents=[common_parser],
+            add_help=False,
+            description=self.do_compact.__doc__,
+            epilog=compact_epilog,
+            formatter_class=argparse.RawDescriptionHelpFormatter,
+            help="compact segment files / free space in repo",
+        )
         subparser.set_defaults(func=self.do_compact)
-        subparser.add_argument('--threshold', metavar='PERCENT', dest='threshold',
-                               type=int, default=10,
-                               help='set minimum threshold for saved space in PERCENT (Default: 10)')
+        subparser.add_argument(
+            "--threshold",
+            metavar="PERCENT",
+            dest="threshold",
+            type=int,
+            default=10,
+            help="set minimum threshold for saved space in PERCENT (Default: 10)",
+        )
 
         # borg config
-        config_epilog = process_epilog("""
+        config_epilog = process_epilog(
+            """
         This command gets and sets options in a local repository or cache config file.
         For security reasons, this command only works on local repositories.
 
@@ -3438,29 +3985,34 @@ class Archiver:
 
         By default, borg config manipulates the repository config file. Using ``--cache``
         edits the repository cache's config file instead.
-        """)
-        subparser = subparsers.add_parser('config', parents=[common_parser], add_help=False,
-                                          description=self.do_config.__doc__,
-                                          epilog=config_epilog,
-                                          formatter_class=argparse.RawDescriptionHelpFormatter,
-                                          help='get and set configuration values')
+        """
+        )
+        subparser = subparsers.add_parser(
+            "config",
+            parents=[common_parser],
+            add_help=False,
+            description=self.do_config.__doc__,
+            epilog=config_epilog,
+            formatter_class=argparse.RawDescriptionHelpFormatter,
+            help="get and set configuration values",
+        )
         subparser.set_defaults(func=self.do_config)
-        subparser.add_argument('-c', '--cache', dest='cache', action='store_true',
-                               help='get and set values from the repo cache')
+        subparser.add_argument(
+            "-c", "--cache", dest="cache", action="store_true", help="get and set values from the repo cache"
+        )
 
         group = subparser.add_mutually_exclusive_group()
-        group.add_argument('-d', '--delete', dest='delete', action='store_true',
-                               help='delete the key from the config file')
-        group.add_argument('-l', '--list', dest='list', action='store_true',
-                               help='list the configuration of the repo')
+        group.add_argument(
+            "-d", "--delete", dest="delete", action="store_true", help="delete the key from the config file"
+        )
+        group.add_argument("-l", "--list", dest="list", action="store_true", help="list the configuration of the repo")
 
-        subparser.add_argument('name', metavar='NAME', nargs='?',
-                               help='name of config key')
-        subparser.add_argument('value', metavar='VALUE', nargs='?',
-                               help='new value for key')
+        subparser.add_argument("name", metavar="NAME", nargs="?", help="name of config key")
+        subparser.add_argument("value", metavar="VALUE", nargs="?", help="new value for key")
 
         # borg create
-        create_epilog = process_epilog("""
+        create_epilog = process_epilog(
+            """
         This command creates a backup archive containing all files found while recursively
         traversing all paths specified. Paths are added to the archive as they are given,
         that means if relative paths are desired, the command has to be run from the correct
@@ -3637,277 +4189,473 @@ class Archiver:
 
         By default, the content read from stdin is stored in a file called 'stdin'.
         Use ``--stdin-name`` to change the name.
-        """)
+        """
+        )
 
-        subparser = subparsers.add_parser('create', parents=[common_parser], add_help=False,
-                                          description=self.do_create.__doc__,
-                                          epilog=create_epilog,
-                                          formatter_class=argparse.RawDescriptionHelpFormatter,
-                                          help='create backup')
+        subparser = subparsers.add_parser(
+            "create",
+            parents=[common_parser],
+            add_help=False,
+            description=self.do_create.__doc__,
+            epilog=create_epilog,
+            formatter_class=argparse.RawDescriptionHelpFormatter,
+            help="create backup",
+        )
         subparser.set_defaults(func=self.do_create)
 
         # note: --dry-run and --stats are mutually exclusive, but we do not want to abort when
         #  parsing, but rather proceed with the dry-run, but without stats (see run() method).
-        subparser.add_argument('-n', '--dry-run', dest='dry_run', action='store_true',
-                               help='do not create a backup archive')
-        subparser.add_argument('-s', '--stats', dest='stats', action='store_true',
-                               help='print statistics for the created archive')
+        subparser.add_argument(
+            "-n", "--dry-run", dest="dry_run", action="store_true", help="do not create a backup archive"
+        )
+        subparser.add_argument(
+            "-s", "--stats", dest="stats", action="store_true", help="print statistics for the created archive"
+        )
 
-        subparser.add_argument('--list', dest='output_list', action='store_true',
-                               help='output verbose list of items (files, dirs, ...)')
-        subparser.add_argument('--filter', metavar='STATUSCHARS', dest='output_filter', action=Highlander,
-                               help='only display items with the given status characters (see description)')
-        subparser.add_argument('--json', action='store_true',
-                               help='output stats as JSON. Implies ``--stats``.')
-        subparser.add_argument('--no-cache-sync', dest='no_cache_sync', action='store_true',
-                               help='experimental: do not synchronize the cache. Implies not using the files cache.')
-        subparser.add_argument('--stdin-name', metavar='NAME', dest='stdin_name', default='stdin',
-                               help='use NAME in archive for stdin data (default: %(default)r)')
-        subparser.add_argument('--stdin-user', metavar='USER', dest='stdin_user', default=uid2user(0),
-                               help='set user USER in archive for stdin data (default: %(default)r)')
-        subparser.add_argument('--stdin-group', metavar='GROUP', dest='stdin_group', default=gid2group(0),
-                               help='set group GROUP in archive for stdin data (default: %(default)r)')
-        subparser.add_argument('--stdin-mode', metavar='M', dest='stdin_mode', type=lambda s: int(s, 8), default=STDIN_MODE_DEFAULT,
-                              help='set mode to M in archive for stdin data (default: %(default)04o)')
-        subparser.add_argument('--content-from-command', action='store_true',
-                               help='interpret PATH as command and store its stdout. See also section Reading from'
-                                    ' stdin below.')
-        subparser.add_argument('--paths-from-stdin', action='store_true',
-                               help='read DELIM-separated list of paths to backup from stdin. Will not '
-                                    'recurse into directories.')
-        subparser.add_argument('--paths-from-command', action='store_true',
-                               help='interpret PATH as command and treat its output as ``--paths-from-stdin``')
-        subparser.add_argument('--paths-delimiter', metavar='DELIM',
-                               help='set path delimiter for ``--paths-from-stdin`` and ``--paths-from-command`` (default: \\n) ')
+        subparser.add_argument(
+            "--list", dest="output_list", action="store_true", help="output verbose list of items (files, dirs, ...)"
+        )
+        subparser.add_argument(
+            "--filter",
+            metavar="STATUSCHARS",
+            dest="output_filter",
+            action=Highlander,
+            help="only display items with the given status characters (see description)",
+        )
+        subparser.add_argument("--json", action="store_true", help="output stats as JSON. Implies ``--stats``.")
+        subparser.add_argument(
+            "--no-cache-sync",
+            dest="no_cache_sync",
+            action="store_true",
+            help="experimental: do not synchronize the cache. Implies not using the files cache.",
+        )
+        subparser.add_argument(
+            "--stdin-name",
+            metavar="NAME",
+            dest="stdin_name",
+            default="stdin",
+            help="use NAME in archive for stdin data (default: %(default)r)",
+        )
+        subparser.add_argument(
+            "--stdin-user",
+            metavar="USER",
+            dest="stdin_user",
+            default=uid2user(0),
+            help="set user USER in archive for stdin data (default: %(default)r)",
+        )
+        subparser.add_argument(
+            "--stdin-group",
+            metavar="GROUP",
+            dest="stdin_group",
+            default=gid2group(0),
+            help="set group GROUP in archive for stdin data (default: %(default)r)",
+        )
+        subparser.add_argument(
+            "--stdin-mode",
+            metavar="M",
+            dest="stdin_mode",
+            type=lambda s: int(s, 8),
+            default=STDIN_MODE_DEFAULT,
+            help="set mode to M in archive for stdin data (default: %(default)04o)",
+        )
+        subparser.add_argument(
+            "--content-from-command",
+            action="store_true",
+            help="interpret PATH as command and store its stdout. See also section Reading from" " stdin below.",
+        )
+        subparser.add_argument(
+            "--paths-from-stdin",
+            action="store_true",
+            help="read DELIM-separated list of paths to backup from stdin. Will not " "recurse into directories.",
+        )
+        subparser.add_argument(
+            "--paths-from-command",
+            action="store_true",
+            help="interpret PATH as command and treat its output as ``--paths-from-stdin``",
+        )
+        subparser.add_argument(
+            "--paths-delimiter",
+            metavar="DELIM",
+            help="set path delimiter for ``--paths-from-stdin`` and ``--paths-from-command`` (default: \\n) ",
+        )
 
         exclude_group = define_exclusion_group(subparser, tag_files=True)
-        exclude_group.add_argument('--exclude-nodump', dest='exclude_nodump', action='store_true',
-                                   help='exclude files flagged NODUMP')
+        exclude_group.add_argument(
+            "--exclude-nodump", dest="exclude_nodump", action="store_true", help="exclude files flagged NODUMP"
+        )
 
-        fs_group = subparser.add_argument_group('Filesystem options')
-        fs_group.add_argument('-x', '--one-file-system', dest='one_file_system', action='store_true',
-                              help='stay in the same file system and do not store mount points of other file systems.  This might behave different from your expectations, see the docs.')
-        fs_group.add_argument('--numeric-ids', dest='numeric_ids', action='store_true',
-                              help='only store numeric user and group identifiers')
-        fs_group.add_argument('--atime', dest='atime', action='store_true',
-                              help='do store atime into archive')
-        fs_group.add_argument('--noctime', dest='noctime', action='store_true',
-                              help='do not store ctime into archive')
-        fs_group.add_argument('--nobirthtime', dest='nobirthtime', action='store_true',
-                              help='do not store birthtime (creation date) into archive')
-        fs_group.add_argument('--noflags', dest='noflags', action='store_true',
-                              help='do not read and store flags (e.g. NODUMP, IMMUTABLE) into archive')
-        fs_group.add_argument('--noacls', dest='noacls', action='store_true',
-                              help='do not read and store ACLs into archive')
-        fs_group.add_argument('--noxattrs', dest='noxattrs', action='store_true',
-                              help='do not read and store xattrs into archive')
-        fs_group.add_argument('--sparse', dest='sparse', action='store_true',
-                               help='detect sparse holes in input (supported only by fixed chunker)')
-        fs_group.add_argument('--files-cache', metavar='MODE', dest='files_cache_mode', action=Highlander,
-                              type=FilesCacheMode, default=FILES_CACHE_MODE_UI_DEFAULT,
-                              help='operate files cache in MODE. default: %s' % FILES_CACHE_MODE_UI_DEFAULT)
-        fs_group.add_argument('--read-special', dest='read_special', action='store_true',
-                              help='open and read block and char device files as well as FIFOs as if they were '
-                                   'regular files. Also follows symlinks pointing to these kinds of files.')
+        fs_group = subparser.add_argument_group("Filesystem options")
+        fs_group.add_argument(
+            "-x",
+            "--one-file-system",
+            dest="one_file_system",
+            action="store_true",
+            help="stay in the same file system and do not store mount points of other file systems.  This might behave different from your expectations, see the docs.",
+        )
+        fs_group.add_argument(
+            "--numeric-ids",
+            dest="numeric_ids",
+            action="store_true",
+            help="only store numeric user and group identifiers",
+        )
+        fs_group.add_argument("--atime", dest="atime", action="store_true", help="do store atime into archive")
+        fs_group.add_argument("--noctime", dest="noctime", action="store_true", help="do not store ctime into archive")
+        fs_group.add_argument(
+            "--nobirthtime",
+            dest="nobirthtime",
+            action="store_true",
+            help="do not store birthtime (creation date) into archive",
+        )
+        fs_group.add_argument(
+            "--noflags",
+            dest="noflags",
+            action="store_true",
+            help="do not read and store flags (e.g. NODUMP, IMMUTABLE) into archive",
+        )
+        fs_group.add_argument(
+            "--noacls", dest="noacls", action="store_true", help="do not read and store ACLs into archive"
+        )
+        fs_group.add_argument(
+            "--noxattrs", dest="noxattrs", action="store_true", help="do not read and store xattrs into archive"
+        )
+        fs_group.add_argument(
+            "--sparse",
+            dest="sparse",
+            action="store_true",
+            help="detect sparse holes in input (supported only by fixed chunker)",
+        )
+        fs_group.add_argument(
+            "--files-cache",
+            metavar="MODE",
+            dest="files_cache_mode",
+            action=Highlander,
+            type=FilesCacheMode,
+            default=FILES_CACHE_MODE_UI_DEFAULT,
+            help="operate files cache in MODE. default: %s" % FILES_CACHE_MODE_UI_DEFAULT,
+        )
+        fs_group.add_argument(
+            "--read-special",
+            dest="read_special",
+            action="store_true",
+            help="open and read block and char device files as well as FIFOs as if they were "
+            "regular files. Also follows symlinks pointing to these kinds of files.",
+        )
 
-        archive_group = subparser.add_argument_group('Archive options')
-        archive_group.add_argument('--comment', dest='comment', metavar='COMMENT', type=CommentSpec, default='',
-                                   help='add a comment text to the archive')
-        archive_group.add_argument('--timestamp', metavar='TIMESTAMP', dest='timestamp',
-                                   type=timestamp, default=None,
-                                   help='manually specify the archive creation date/time (UTC, yyyy-mm-ddThh:mm:ss format). '
-                                        'Alternatively, give a reference file/directory.')
-        archive_group.add_argument('-c', '--checkpoint-interval', metavar='SECONDS', dest='checkpoint_interval',
-                                   type=int, default=1800,
-                                   help='write checkpoint every SECONDS seconds (Default: 1800)')
-        archive_group.add_argument('--chunker-params', metavar='PARAMS', dest='chunker_params',
-                                   type=ChunkerParams, default=CHUNKER_PARAMS, action=Highlander,
-                                   help='specify the chunker parameters (ALGO, CHUNK_MIN_EXP, CHUNK_MAX_EXP, '
-                                        'HASH_MASK_BITS, HASH_WINDOW_SIZE). default: %s,%d,%d,%d,%d' % CHUNKER_PARAMS)
-        archive_group.add_argument('-C', '--compression', metavar='COMPRESSION', dest='compression',
-                                   type=CompressionSpec, default=CompressionSpec('lz4'),
-                                   help='select compression algorithm, see the output of the '
-                                        '"borg help compression" command for details.')
+        archive_group = subparser.add_argument_group("Archive options")
+        archive_group.add_argument(
+            "--comment",
+            dest="comment",
+            metavar="COMMENT",
+            type=CommentSpec,
+            default="",
+            help="add a comment text to the archive",
+        )
+        archive_group.add_argument(
+            "--timestamp",
+            metavar="TIMESTAMP",
+            dest="timestamp",
+            type=timestamp,
+            default=None,
+            help="manually specify the archive creation date/time (UTC, yyyy-mm-ddThh:mm:ss format). "
+            "Alternatively, give a reference file/directory.",
+        )
+        archive_group.add_argument(
+            "-c",
+            "--checkpoint-interval",
+            metavar="SECONDS",
+            dest="checkpoint_interval",
+            type=int,
+            default=1800,
+            help="write checkpoint every SECONDS seconds (Default: 1800)",
+        )
+        archive_group.add_argument(
+            "--chunker-params",
+            metavar="PARAMS",
+            dest="chunker_params",
+            type=ChunkerParams,
+            default=CHUNKER_PARAMS,
+            action=Highlander,
+            help="specify the chunker parameters (ALGO, CHUNK_MIN_EXP, CHUNK_MAX_EXP, "
+            "HASH_MASK_BITS, HASH_WINDOW_SIZE). default: %s,%d,%d,%d,%d" % CHUNKER_PARAMS,
+        )
+        archive_group.add_argument(
+            "-C",
+            "--compression",
+            metavar="COMPRESSION",
+            dest="compression",
+            type=CompressionSpec,
+            default=CompressionSpec("lz4"),
+            help="select compression algorithm, see the output of the " '"borg help compression" command for details.',
+        )
 
-        subparser.add_argument('name', metavar='NAME', type=NameSpec,
-                               help='specify the archive name')
-        subparser.add_argument('paths', metavar='PATH', nargs='*', type=str,
-                               help='paths to archive')
+        subparser.add_argument("name", metavar="NAME", type=NameSpec, help="specify the archive name")
+        subparser.add_argument("paths", metavar="PATH", nargs="*", type=str, help="paths to archive")
 
         # borg debug
-        debug_epilog = process_epilog("""
+        debug_epilog = process_epilog(
+            """
         These commands are not intended for normal use and potentially very
         dangerous if used incorrectly.
 
         They exist to improve debugging capabilities without direct system access, e.g.
         in case you ever run into some severe malfunction. Use them only if you know
-        what you are doing or if a trusted developer tells you what to do.""")
+        what you are doing or if a trusted developer tells you what to do."""
+        )
 
-        subparser = subparsers.add_parser('debug', parents=[mid_common_parser], add_help=False,
-                                          description='debugging command (not intended for normal use)',
-                                          epilog=debug_epilog,
-                                          formatter_class=argparse.RawDescriptionHelpFormatter,
-                                          help='debugging command (not intended for normal use)')
+        subparser = subparsers.add_parser(
+            "debug",
+            parents=[mid_common_parser],
+            add_help=False,
+            description="debugging command (not intended for normal use)",
+            epilog=debug_epilog,
+            formatter_class=argparse.RawDescriptionHelpFormatter,
+            help="debugging command (not intended for normal use)",
+        )
 
-        debug_parsers = subparser.add_subparsers(title='required arguments', metavar='<command>')
+        debug_parsers = subparser.add_subparsers(title="required arguments", metavar="<command>")
         subparser.set_defaults(fallback_func=functools.partial(self.do_subcommand_help, subparser))
 
-        debug_info_epilog = process_epilog("""
+        debug_info_epilog = process_epilog(
+            """
         This command displays some system information that might be useful for bug
         reports and debugging problems. If a traceback happens, this information is
         already appended at the end of the traceback.
-        """)
-        subparser = debug_parsers.add_parser('info', parents=[common_parser], add_help=False,
-                                          description=self.do_debug_info.__doc__,
-                                          epilog=debug_info_epilog,
-                                          formatter_class=argparse.RawDescriptionHelpFormatter,
-                                          help='show system infos for debugging / bug reports (debug)')
+        """
+        )
+        subparser = debug_parsers.add_parser(
+            "info",
+            parents=[common_parser],
+            add_help=False,
+            description=self.do_debug_info.__doc__,
+            epilog=debug_info_epilog,
+            formatter_class=argparse.RawDescriptionHelpFormatter,
+            help="show system infos for debugging / bug reports (debug)",
+        )
         subparser.set_defaults(func=self.do_debug_info)
 
-        debug_dump_archive_items_epilog = process_epilog("""
+        debug_dump_archive_items_epilog = process_epilog(
+            """
         This command dumps raw (but decrypted and decompressed) archive items (only metadata) to files.
-        """)
-        subparser = debug_parsers.add_parser('dump-archive-items', parents=[common_parser], add_help=False,
-                                          description=self.do_debug_dump_archive_items.__doc__,
-                                          epilog=debug_dump_archive_items_epilog,
-                                          formatter_class=argparse.RawDescriptionHelpFormatter,
-                                          help='dump archive items (metadata) (debug)')
+        """
+        )
+        subparser = debug_parsers.add_parser(
+            "dump-archive-items",
+            parents=[common_parser],
+            add_help=False,
+            description=self.do_debug_dump_archive_items.__doc__,
+            epilog=debug_dump_archive_items_epilog,
+            formatter_class=argparse.RawDescriptionHelpFormatter,
+            help="dump archive items (metadata) (debug)",
+        )
         subparser.set_defaults(func=self.do_debug_dump_archive_items)
-        subparser.add_argument('name', metavar='NAME', type=NameSpec,
-                               help='specify the archive name')
+        subparser.add_argument("name", metavar="NAME", type=NameSpec, help="specify the archive name")
 
-        debug_dump_archive_epilog = process_epilog("""
+        debug_dump_archive_epilog = process_epilog(
+            """
         This command dumps all metadata of an archive in a decoded form to a file.
-        """)
-        subparser = debug_parsers.add_parser('dump-archive', parents=[common_parser], add_help=False,
-                                          description=self.do_debug_dump_archive.__doc__,
-                                          epilog=debug_dump_archive_epilog,
-                                          formatter_class=argparse.RawDescriptionHelpFormatter,
-                                          help='dump decoded archive metadata (debug)')
+        """
+        )
+        subparser = debug_parsers.add_parser(
+            "dump-archive",
+            parents=[common_parser],
+            add_help=False,
+            description=self.do_debug_dump_archive.__doc__,
+            epilog=debug_dump_archive_epilog,
+            formatter_class=argparse.RawDescriptionHelpFormatter,
+            help="dump decoded archive metadata (debug)",
+        )
         subparser.set_defaults(func=self.do_debug_dump_archive)
-        subparser.add_argument('name', metavar='NAME', type=NameSpec,
-                               help='specify the archive name')
-        subparser.add_argument('path', metavar='PATH', type=str,
-                               help='file to dump data into')
+        subparser.add_argument("name", metavar="NAME", type=NameSpec, help="specify the archive name")
+        subparser.add_argument("path", metavar="PATH", type=str, help="file to dump data into")
 
-        debug_dump_manifest_epilog = process_epilog("""
+        debug_dump_manifest_epilog = process_epilog(
+            """
         This command dumps manifest metadata of a repository in a decoded form to a file.
-        """)
-        subparser = debug_parsers.add_parser('dump-manifest', parents=[common_parser], add_help=False,
-                                          description=self.do_debug_dump_manifest.__doc__,
-                                          epilog=debug_dump_manifest_epilog,
-                                          formatter_class=argparse.RawDescriptionHelpFormatter,
-                                          help='dump decoded repository metadata (debug)')
+        """
+        )
+        subparser = debug_parsers.add_parser(
+            "dump-manifest",
+            parents=[common_parser],
+            add_help=False,
+            description=self.do_debug_dump_manifest.__doc__,
+            epilog=debug_dump_manifest_epilog,
+            formatter_class=argparse.RawDescriptionHelpFormatter,
+            help="dump decoded repository metadata (debug)",
+        )
         subparser.set_defaults(func=self.do_debug_dump_manifest)
-        subparser.add_argument('path', metavar='PATH', type=str,
-                               help='file to dump data into')
+        subparser.add_argument("path", metavar="PATH", type=str, help="file to dump data into")
 
-        debug_dump_repo_objs_epilog = process_epilog("""
+        debug_dump_repo_objs_epilog = process_epilog(
+            """
         This command dumps raw (but decrypted and decompressed) repo objects to files.
-        """)
-        subparser = debug_parsers.add_parser('dump-repo-objs', parents=[common_parser], add_help=False,
-                                          description=self.do_debug_dump_repo_objs.__doc__,
-                                          epilog=debug_dump_repo_objs_epilog,
-                                          formatter_class=argparse.RawDescriptionHelpFormatter,
-                                          help='dump repo objects (debug)')
+        """
+        )
+        subparser = debug_parsers.add_parser(
+            "dump-repo-objs",
+            parents=[common_parser],
+            add_help=False,
+            description=self.do_debug_dump_repo_objs.__doc__,
+            epilog=debug_dump_repo_objs_epilog,
+            formatter_class=argparse.RawDescriptionHelpFormatter,
+            help="dump repo objects (debug)",
+        )
         subparser.set_defaults(func=self.do_debug_dump_repo_objs)
-        subparser.add_argument('--ghost', dest='ghost', action='store_true',
-                               help='dump all segment file contents, including deleted/uncommitted objects and commits.')
-        subparser.add_argument('--segment', metavar='SEG', dest='segment', default=None, type=positive_int_validator,
-                               help='used together with --ghost: limit processing to given segment.')
-        subparser.add_argument('--offset', metavar='OFFS', dest='offset', default=None, type=positive_int_validator,
-                               help='used together with --ghost: limit processing to given offset.')
+        subparser.add_argument(
+            "--ghost",
+            dest="ghost",
+            action="store_true",
+            help="dump all segment file contents, including deleted/uncommitted objects and commits.",
+        )
+        subparser.add_argument(
+            "--segment",
+            metavar="SEG",
+            dest="segment",
+            default=None,
+            type=positive_int_validator,
+            help="used together with --ghost: limit processing to given segment.",
+        )
+        subparser.add_argument(
+            "--offset",
+            metavar="OFFS",
+            dest="offset",
+            default=None,
+            type=positive_int_validator,
+            help="used together with --ghost: limit processing to given offset.",
+        )
 
-        debug_search_repo_objs_epilog = process_epilog("""
+        debug_search_repo_objs_epilog = process_epilog(
+            """
         This command searches raw (but decrypted and decompressed) repo objects for a specific bytes sequence.
-        """)
-        subparser = debug_parsers.add_parser('search-repo-objs', parents=[common_parser], add_help=False,
-                                          description=self.do_debug_search_repo_objs.__doc__,
-                                          epilog=debug_search_repo_objs_epilog,
-                                          formatter_class=argparse.RawDescriptionHelpFormatter,
-                                          help='search repo objects (debug)')
+        """
+        )
+        subparser = debug_parsers.add_parser(
+            "search-repo-objs",
+            parents=[common_parser],
+            add_help=False,
+            description=self.do_debug_search_repo_objs.__doc__,
+            epilog=debug_search_repo_objs_epilog,
+            formatter_class=argparse.RawDescriptionHelpFormatter,
+            help="search repo objects (debug)",
+        )
         subparser.set_defaults(func=self.do_debug_search_repo_objs)
-        subparser.add_argument('wanted', metavar='WANTED', type=str,
-                               help='term to search the repo for, either 0x1234abcd hex term or a string')
+        subparser.add_argument(
+            "wanted",
+            metavar="WANTED",
+            type=str,
+            help="term to search the repo for, either 0x1234abcd hex term or a string",
+        )
 
-        debug_get_obj_epilog = process_epilog("""
+        debug_get_obj_epilog = process_epilog(
+            """
         This command gets an object from the repository.
-        """)
-        subparser = debug_parsers.add_parser('get-obj', parents=[common_parser], add_help=False,
-                                          description=self.do_debug_get_obj.__doc__,
-                                          epilog=debug_get_obj_epilog,
-                                          formatter_class=argparse.RawDescriptionHelpFormatter,
-                                          help='get object from repository (debug)')
+        """
+        )
+        subparser = debug_parsers.add_parser(
+            "get-obj",
+            parents=[common_parser],
+            add_help=False,
+            description=self.do_debug_get_obj.__doc__,
+            epilog=debug_get_obj_epilog,
+            formatter_class=argparse.RawDescriptionHelpFormatter,
+            help="get object from repository (debug)",
+        )
         subparser.set_defaults(func=self.do_debug_get_obj)
-        subparser.add_argument('id', metavar='ID', type=str,
-                               help='hex object ID to get from the repo')
-        subparser.add_argument('path', metavar='PATH', type=str,
-                               help='file to write object data into')
+        subparser.add_argument("id", metavar="ID", type=str, help="hex object ID to get from the repo")
+        subparser.add_argument("path", metavar="PATH", type=str, help="file to write object data into")
 
-        debug_put_obj_epilog = process_epilog("""
+        debug_put_obj_epilog = process_epilog(
+            """
         This command puts objects into the repository.
-        """)
-        subparser = debug_parsers.add_parser('put-obj', parents=[common_parser], add_help=False,
-                                          description=self.do_debug_put_obj.__doc__,
-                                          epilog=debug_put_obj_epilog,
-                                          formatter_class=argparse.RawDescriptionHelpFormatter,
-                                          help='put object to repository (debug)')
+        """
+        )
+        subparser = debug_parsers.add_parser(
+            "put-obj",
+            parents=[common_parser],
+            add_help=False,
+            description=self.do_debug_put_obj.__doc__,
+            epilog=debug_put_obj_epilog,
+            formatter_class=argparse.RawDescriptionHelpFormatter,
+            help="put object to repository (debug)",
+        )
         subparser.set_defaults(func=self.do_debug_put_obj)
-        subparser.add_argument('paths', metavar='PATH', nargs='+', type=str,
-                               help='file(s) to read and create object(s) from')
+        subparser.add_argument(
+            "paths", metavar="PATH", nargs="+", type=str, help="file(s) to read and create object(s) from"
+        )
 
-        debug_delete_obj_epilog = process_epilog("""
+        debug_delete_obj_epilog = process_epilog(
+            """
         This command deletes objects from the repository.
-        """)
-        subparser = debug_parsers.add_parser('delete-obj', parents=[common_parser], add_help=False,
-                                          description=self.do_debug_delete_obj.__doc__,
-                                          epilog=debug_delete_obj_epilog,
-                                          formatter_class=argparse.RawDescriptionHelpFormatter,
-                                          help='delete object from repository (debug)')
+        """
+        )
+        subparser = debug_parsers.add_parser(
+            "delete-obj",
+            parents=[common_parser],
+            add_help=False,
+            description=self.do_debug_delete_obj.__doc__,
+            epilog=debug_delete_obj_epilog,
+            formatter_class=argparse.RawDescriptionHelpFormatter,
+            help="delete object from repository (debug)",
+        )
         subparser.set_defaults(func=self.do_debug_delete_obj)
-        subparser.add_argument('ids', metavar='IDs', nargs='+', type=str,
-                               help='hex object ID(s) to delete from the repo')
+        subparser.add_argument(
+            "ids", metavar="IDs", nargs="+", type=str, help="hex object ID(s) to delete from the repo"
+        )
 
-        debug_refcount_obj_epilog = process_epilog("""
+        debug_refcount_obj_epilog = process_epilog(
+            """
         This command displays the reference count for objects from the repository.
-        """)
-        subparser = debug_parsers.add_parser('refcount-obj', parents=[common_parser], add_help=False,
-                                          description=self.do_debug_refcount_obj.__doc__,
-                                          epilog=debug_refcount_obj_epilog,
-                                          formatter_class=argparse.RawDescriptionHelpFormatter,
-                                          help='show refcount for object from repository (debug)')
+        """
+        )
+        subparser = debug_parsers.add_parser(
+            "refcount-obj",
+            parents=[common_parser],
+            add_help=False,
+            description=self.do_debug_refcount_obj.__doc__,
+            epilog=debug_refcount_obj_epilog,
+            formatter_class=argparse.RawDescriptionHelpFormatter,
+            help="show refcount for object from repository (debug)",
+        )
         subparser.set_defaults(func=self.do_debug_refcount_obj)
-        subparser.add_argument('ids', metavar='IDs', nargs='+', type=str,
-                               help='hex object ID(s) to show refcounts for')
+        subparser.add_argument("ids", metavar="IDs", nargs="+", type=str, help="hex object ID(s) to show refcounts for")
 
-        debug_dump_hints_epilog = process_epilog("""
+        debug_dump_hints_epilog = process_epilog(
+            """
         This command dumps the repository hints data.
-        """)
-        subparser = debug_parsers.add_parser('dump-hints', parents=[common_parser], add_help=False,
-                                          description=self.do_debug_dump_hints.__doc__,
-                                          epilog=debug_dump_hints_epilog,
-                                          formatter_class=argparse.RawDescriptionHelpFormatter,
-                                          help='dump repo hints (debug)')
+        """
+        )
+        subparser = debug_parsers.add_parser(
+            "dump-hints",
+            parents=[common_parser],
+            add_help=False,
+            description=self.do_debug_dump_hints.__doc__,
+            epilog=debug_dump_hints_epilog,
+            formatter_class=argparse.RawDescriptionHelpFormatter,
+            help="dump repo hints (debug)",
+        )
         subparser.set_defaults(func=self.do_debug_dump_hints)
-        subparser.add_argument('path', metavar='PATH', type=str,
-                               help='file to dump data into')
+        subparser.add_argument("path", metavar="PATH", type=str, help="file to dump data into")
 
-        debug_convert_profile_epilog = process_epilog("""
+        debug_convert_profile_epilog = process_epilog(
+            """
         Convert a Borg profile to a Python cProfile compatible profile.
-        """)
-        subparser = debug_parsers.add_parser('convert-profile', parents=[common_parser], add_help=False,
-                                          description=self.do_debug_convert_profile.__doc__,
-                                          epilog=debug_convert_profile_epilog,
-                                          formatter_class=argparse.RawDescriptionHelpFormatter,
-                                          help='convert Borg profile to Python profile (debug)')
+        """
+        )
+        subparser = debug_parsers.add_parser(
+            "convert-profile",
+            parents=[common_parser],
+            add_help=False,
+            description=self.do_debug_convert_profile.__doc__,
+            epilog=debug_convert_profile_epilog,
+            formatter_class=argparse.RawDescriptionHelpFormatter,
+            help="convert Borg profile to Python profile (debug)",
+        )
         subparser.set_defaults(func=self.do_debug_convert_profile)
-        subparser.add_argument('input', metavar='INPUT', type=argparse.FileType('rb'),
-                               help='Borg profile')
-        subparser.add_argument('output', metavar='OUTPUT', type=argparse.FileType('wb'),
-                               help='Output file')
+        subparser.add_argument("input", metavar="INPUT", type=argparse.FileType("rb"), help="Borg profile")
+        subparser.add_argument("output", metavar="OUTPUT", type=argparse.FileType("wb"), help="Output file")
 
         # borg rdelete
-        rdelete_epilog = process_epilog("""
+        rdelete_epilog = process_epilog(
+            """
         This command deletes the complete repository.
 
         When you delete a complete repository, the security info and local cache for it
@@ -3916,27 +4664,45 @@ class Archiver:
         ``--keep-security-info`` option.
 
         Always first use ``--dry-run --list`` to see what would be deleted.
-        """)
-        subparser = subparsers.add_parser('rdelete', parents=[common_parser], add_help=False,
-                                          description=self.do_rdelete.__doc__,
-                                          epilog=rdelete_epilog,
-                                          formatter_class=argparse.RawDescriptionHelpFormatter,
-                                          help='delete repository')
+        """
+        )
+        subparser = subparsers.add_parser(
+            "rdelete",
+            parents=[common_parser],
+            add_help=False,
+            description=self.do_rdelete.__doc__,
+            epilog=rdelete_epilog,
+            formatter_class=argparse.RawDescriptionHelpFormatter,
+            help="delete repository",
+        )
         subparser.set_defaults(func=self.do_rdelete)
-        subparser.add_argument('-n', '--dry-run', dest='dry_run', action='store_true',
-                               help='do not change repository')
-        subparser.add_argument('--list', dest='output_list', action='store_true',
-                               help='output verbose list of archives')
-        subparser.add_argument('--force', dest='forced', action='count', default=0,
-                               help='force deletion of corrupted archives, '
-                                    'use ``--force --force`` in case ``--force`` does not work.')
-        subparser.add_argument('--cache-only', dest='cache_only', action='store_true',
-                               help='delete only the local cache for the given repository')
-        subparser.add_argument('--keep-security-info', dest='keep_security_info', action='store_true',
-                               help='keep the local security info when deleting a repository')
+        subparser.add_argument("-n", "--dry-run", dest="dry_run", action="store_true", help="do not change repository")
+        subparser.add_argument(
+            "--list", dest="output_list", action="store_true", help="output verbose list of archives"
+        )
+        subparser.add_argument(
+            "--force",
+            dest="forced",
+            action="count",
+            default=0,
+            help="force deletion of corrupted archives, " "use ``--force --force`` in case ``--force`` does not work.",
+        )
+        subparser.add_argument(
+            "--cache-only",
+            dest="cache_only",
+            action="store_true",
+            help="delete only the local cache for the given repository",
+        )
+        subparser.add_argument(
+            "--keep-security-info",
+            dest="keep_security_info",
+            action="store_true",
+            help="keep the local security info when deleting a repository",
+        )
 
         # borg delete
-        delete_epilog = process_epilog("""
+        delete_epilog = process_epilog(
+            """
         This command deletes archives from the repository.
 
         Important: When deleting archives, repository disk space is **not** freed until
@@ -3954,34 +4720,58 @@ class Archiver:
         see :ref:`borg_patterns`).
 
         Always first use ``--dry-run --list`` to see what would be deleted.
-        """)
-        subparser = subparsers.add_parser('delete', parents=[common_parser], add_help=False,
-                                          description=self.do_delete.__doc__,
-                                          epilog=delete_epilog,
-                                          formatter_class=argparse.RawDescriptionHelpFormatter,
-                                          help='delete archive')
+        """
+        )
+        subparser = subparsers.add_parser(
+            "delete",
+            parents=[common_parser],
+            add_help=False,
+            description=self.do_delete.__doc__,
+            epilog=delete_epilog,
+            formatter_class=argparse.RawDescriptionHelpFormatter,
+            help="delete archive",
+        )
         subparser.set_defaults(func=self.do_delete)
-        subparser.add_argument('-n', '--dry-run', dest='dry_run', action='store_true',
-                               help='do not change repository')
-        subparser.add_argument('--list', dest='output_list', action='store_true',
-                               help='output verbose list of archives')
-        subparser.add_argument('--consider-checkpoints', action='store_true', dest='consider_checkpoints',
-                               help='consider checkpoint archives for deletion (default: not considered).')
-        subparser.add_argument('-s', '--stats', dest='stats', action='store_true',
-                               help='print statistics for the deleted archive')
-        subparser.add_argument('--cache-only', dest='cache_only', action='store_true',
-                               help='delete only the local cache for the given repository')
-        subparser.add_argument('--force', dest='forced', action='count', default=0,
-                               help='force deletion of corrupted archives, '
-                                    'use ``--force --force`` in case ``--force`` does not work.')
-        subparser.add_argument('--keep-security-info', dest='keep_security_info', action='store_true',
-                               help='keep the local security info when deleting a repository')
-        subparser.add_argument('--save-space', dest='save_space', action='store_true',
-                               help='work slower, but using less space')
+        subparser.add_argument("-n", "--dry-run", dest="dry_run", action="store_true", help="do not change repository")
+        subparser.add_argument(
+            "--list", dest="output_list", action="store_true", help="output verbose list of archives"
+        )
+        subparser.add_argument(
+            "--consider-checkpoints",
+            action="store_true",
+            dest="consider_checkpoints",
+            help="consider checkpoint archives for deletion (default: not considered).",
+        )
+        subparser.add_argument(
+            "-s", "--stats", dest="stats", action="store_true", help="print statistics for the deleted archive"
+        )
+        subparser.add_argument(
+            "--cache-only",
+            dest="cache_only",
+            action="store_true",
+            help="delete only the local cache for the given repository",
+        )
+        subparser.add_argument(
+            "--force",
+            dest="forced",
+            action="count",
+            default=0,
+            help="force deletion of corrupted archives, " "use ``--force --force`` in case ``--force`` does not work.",
+        )
+        subparser.add_argument(
+            "--keep-security-info",
+            dest="keep_security_info",
+            action="store_true",
+            help="keep the local security info when deleting a repository",
+        )
+        subparser.add_argument(
+            "--save-space", dest="save_space", action="store_true", help="work slower, but using less space"
+        )
         define_archive_filters_group(subparser)
 
         # borg transfer
-        transfer_epilog = process_epilog("""
+        transfer_epilog = process_epilog(
+            """
         This command transfers archives from one repository to another repository.
         Optionally, it can also upgrade the transferred data.
 
@@ -4008,25 +4798,42 @@ class Archiver:
             borg --repo=DST_REPO transfer --other-repo=SRC_REPO --upgrader=From12To20
 
 
-        """)
-        subparser = subparsers.add_parser('transfer', parents=[common_parser], add_help=False,
-                                          description=self.do_transfer.__doc__,
-                                          epilog=transfer_epilog,
-                                          formatter_class=argparse.RawDescriptionHelpFormatter,
-                                          help='transfer of archives from another repository')
+        """
+        )
+        subparser = subparsers.add_parser(
+            "transfer",
+            parents=[common_parser],
+            add_help=False,
+            description=self.do_transfer.__doc__,
+            epilog=transfer_epilog,
+            formatter_class=argparse.RawDescriptionHelpFormatter,
+            help="transfer of archives from another repository",
+        )
         subparser.set_defaults(func=self.do_transfer)
-        subparser.add_argument('-n', '--dry-run', dest='dry_run', action='store_true',
-                               help='do not change repository, just check')
-        subparser.add_argument('--other-repo', metavar='SRC_REPOSITORY', dest='other_location',
-                               type=location_validator(other=True), default=Location(other=True),
-                               help='transfer archives from the other repository')
-        subparser.add_argument('--upgrader', metavar='UPGRADER', dest='upgrader',
-                               type=str, default='NoOp',
-                               help='use the upgrader to convert transferred data (default: no conversion)')
+        subparser.add_argument(
+            "-n", "--dry-run", dest="dry_run", action="store_true", help="do not change repository, just check"
+        )
+        subparser.add_argument(
+            "--other-repo",
+            metavar="SRC_REPOSITORY",
+            dest="other_location",
+            type=location_validator(other=True),
+            default=Location(other=True),
+            help="transfer archives from the other repository",
+        )
+        subparser.add_argument(
+            "--upgrader",
+            metavar="UPGRADER",
+            dest="upgrader",
+            type=str,
+            default="NoOp",
+            help="use the upgrader to convert transferred data (default: no conversion)",
+        )
         define_archive_filters_group(subparser)
 
         # borg diff
-        diff_epilog = process_epilog("""
+        diff_epilog = process_epilog(
+            """
             This command finds differences (file contents, user/group/mode) between archives.
 
             A repository location and an archive name must be specified for REPO::ARCHIVE1.
@@ -4043,33 +4850,46 @@ class Archiver:
             Note that the chunker params changed from Borg 0.xx to 1.0.
 
             For more help on include/exclude patterns, see the :ref:`borg_patterns` command output.
-            """)
-        subparser = subparsers.add_parser('diff', parents=[common_parser], add_help=False,
-                                          description=self.do_diff.__doc__,
-                                          epilog=diff_epilog,
-                                          formatter_class=argparse.RawDescriptionHelpFormatter,
-                                          help='find differences in archive contents')
+            """
+        )
+        subparser = subparsers.add_parser(
+            "diff",
+            parents=[common_parser],
+            add_help=False,
+            description=self.do_diff.__doc__,
+            epilog=diff_epilog,
+            formatter_class=argparse.RawDescriptionHelpFormatter,
+            help="find differences in archive contents",
+        )
         subparser.set_defaults(func=self.do_diff)
-        subparser.add_argument('--numeric-ids', dest='numeric_ids', action='store_true',
-                               help='only consider numeric user and group identifiers')
-        subparser.add_argument('--same-chunker-params', dest='same_chunker_params', action='store_true',
-                               help='Override check of chunker parameters.')
-        subparser.add_argument('--sort', dest='sort', action='store_true',
-                               help='Sort the output lines by file path.')
-        subparser.add_argument('--json-lines', action='store_true',
-                               help='Format output as JSON Lines. ')
-        subparser.add_argument('name', metavar='ARCHIVE1',
-                               type=archivename_validator(),
-                               help='ARCHIVE1 name')
-        subparser.add_argument('other_name', metavar='ARCHIVE2',
-                               type=archivename_validator(),
-                               help='ARCHIVE2 name')
-        subparser.add_argument('paths', metavar='PATH', nargs='*', type=str,
-                               help='paths of items inside the archives to compare; patterns are supported')
+        subparser.add_argument(
+            "--numeric-ids",
+            dest="numeric_ids",
+            action="store_true",
+            help="only consider numeric user and group identifiers",
+        )
+        subparser.add_argument(
+            "--same-chunker-params",
+            dest="same_chunker_params",
+            action="store_true",
+            help="Override check of chunker parameters.",
+        )
+        subparser.add_argument("--sort", dest="sort", action="store_true", help="Sort the output lines by file path.")
+        subparser.add_argument("--json-lines", action="store_true", help="Format output as JSON Lines. ")
+        subparser.add_argument("name", metavar="ARCHIVE1", type=archivename_validator(), help="ARCHIVE1 name")
+        subparser.add_argument("other_name", metavar="ARCHIVE2", type=archivename_validator(), help="ARCHIVE2 name")
+        subparser.add_argument(
+            "paths",
+            metavar="PATH",
+            nargs="*",
+            type=str,
+            help="paths of items inside the archives to compare; patterns are supported",
+        )
         define_exclusion_group(subparser)
 
         # borg export-tar
-        export_tar_epilog = process_epilog("""
+        export_tar_epilog = process_epilog(
+            """
         This command creates a tarball from an archive.
 
         When giving '-' as the output FILE, Borg will write a tar stream to standard output.
@@ -4111,30 +4931,42 @@ class Archiver:
 
         ``--progress`` can be slower than no progress display, since it makes one additional
         pass over the archive metadata.
-        """)
-        subparser = subparsers.add_parser('export-tar', parents=[common_parser], add_help=False,
-                                          description=self.do_export_tar.__doc__,
-                                          epilog=export_tar_epilog,
-                                          formatter_class=argparse.RawDescriptionHelpFormatter,
-                                          help='create tarball from archive')
+        """
+        )
+        subparser = subparsers.add_parser(
+            "export-tar",
+            parents=[common_parser],
+            add_help=False,
+            description=self.do_export_tar.__doc__,
+            epilog=export_tar_epilog,
+            formatter_class=argparse.RawDescriptionHelpFormatter,
+            help="create tarball from archive",
+        )
         subparser.set_defaults(func=self.do_export_tar)
-        subparser.add_argument('--tar-filter', dest='tar_filter', default='auto',
-                               help='filter program to pipe data through')
-        subparser.add_argument('--list', dest='output_list', action='store_true',
-                               help='output verbose list of items (files, dirs, ...)')
-        subparser.add_argument('--tar-format', metavar='FMT', dest='tar_format', default='GNU',
-                               choices=('BORG', 'PAX', 'GNU'),
-                               help='select tar format: BORG, PAX or GNU')
-        subparser.add_argument('name', metavar='NAME', type=NameSpec,
-                               help='specify the archive name')
-        subparser.add_argument('tarfile', metavar='FILE',
-                               help='output tar file. "-" to write to stdout instead.')
-        subparser.add_argument('paths', metavar='PATH', nargs='*', type=str,
-                               help='paths to extract; patterns are supported')
+        subparser.add_argument(
+            "--tar-filter", dest="tar_filter", default="auto", help="filter program to pipe data through"
+        )
+        subparser.add_argument(
+            "--list", dest="output_list", action="store_true", help="output verbose list of items (files, dirs, ...)"
+        )
+        subparser.add_argument(
+            "--tar-format",
+            metavar="FMT",
+            dest="tar_format",
+            default="GNU",
+            choices=("BORG", "PAX", "GNU"),
+            help="select tar format: BORG, PAX or GNU",
+        )
+        subparser.add_argument("name", metavar="NAME", type=NameSpec, help="specify the archive name")
+        subparser.add_argument("tarfile", metavar="FILE", help='output tar file. "-" to write to stdout instead.')
+        subparser.add_argument(
+            "paths", metavar="PATH", nargs="*", type=str, help="paths to extract; patterns are supported"
+        )
         define_exclusion_group(subparser, strip_components=True)
 
         # borg extract
-        extract_epilog = process_epilog("""
+        extract_epilog = process_epilog(
+            """
         This command extracts the contents of an archive. By default the entire
         archive is extracted but a subset of files and directories can be selected
         by passing a list of ``PATHs`` as arguments. The file selection can further
@@ -4157,46 +4989,60 @@ class Archiver:
             When parent directories are not extracted (because of using file/directory selection
             or any other reason), borg can not restore parent directories' metadata, e.g. owner,
             group, permission, etc.
-        """)
-        subparser = subparsers.add_parser('extract', parents=[common_parser], add_help=False,
-                                          description=self.do_extract.__doc__,
-                                          epilog=extract_epilog,
-                                          formatter_class=argparse.RawDescriptionHelpFormatter,
-                                          help='extract archive contents')
+        """
+        )
+        subparser = subparsers.add_parser(
+            "extract",
+            parents=[common_parser],
+            add_help=False,
+            description=self.do_extract.__doc__,
+            epilog=extract_epilog,
+            formatter_class=argparse.RawDescriptionHelpFormatter,
+            help="extract archive contents",
+        )
         subparser.set_defaults(func=self.do_extract)
-        subparser.add_argument('--list', dest='output_list', action='store_true',
-                               help='output verbose list of items (files, dirs, ...)')
-        subparser.add_argument('-n', '--dry-run', dest='dry_run', action='store_true',
-                               help='do not actually change any files')
-        subparser.add_argument('--numeric-ids', dest='numeric_ids', action='store_true',
-                               help='only obey numeric user and group identifiers')
-        subparser.add_argument('--noflags', dest='noflags', action='store_true',
-                               help='do not extract/set flags (e.g. NODUMP, IMMUTABLE)')
-        subparser.add_argument('--noacls', dest='noacls', action='store_true',
-                               help='do not extract/set ACLs')
-        subparser.add_argument('--noxattrs', dest='noxattrs', action='store_true',
-                               help='do not extract/set xattrs')
-        subparser.add_argument('--stdout', dest='stdout', action='store_true',
-                               help='write all extracted data to stdout')
-        subparser.add_argument('--sparse', dest='sparse', action='store_true',
-                               help='create holes in output sparse file from all-zero chunks')
-        subparser.add_argument('name', metavar='NAME', type=NameSpec,
-                               help='specify the archive name')
-        subparser.add_argument('paths', metavar='PATH', nargs='*', type=str,
-                               help='paths to extract; patterns are supported')
+        subparser.add_argument(
+            "--list", dest="output_list", action="store_true", help="output verbose list of items (files, dirs, ...)"
+        )
+        subparser.add_argument(
+            "-n", "--dry-run", dest="dry_run", action="store_true", help="do not actually change any files"
+        )
+        subparser.add_argument(
+            "--numeric-ids",
+            dest="numeric_ids",
+            action="store_true",
+            help="only obey numeric user and group identifiers",
+        )
+        subparser.add_argument(
+            "--noflags", dest="noflags", action="store_true", help="do not extract/set flags (e.g. NODUMP, IMMUTABLE)"
+        )
+        subparser.add_argument("--noacls", dest="noacls", action="store_true", help="do not extract/set ACLs")
+        subparser.add_argument("--noxattrs", dest="noxattrs", action="store_true", help="do not extract/set xattrs")
+        subparser.add_argument(
+            "--stdout", dest="stdout", action="store_true", help="write all extracted data to stdout"
+        )
+        subparser.add_argument(
+            "--sparse",
+            dest="sparse",
+            action="store_true",
+            help="create holes in output sparse file from all-zero chunks",
+        )
+        subparser.add_argument("name", metavar="NAME", type=NameSpec, help="specify the archive name")
+        subparser.add_argument(
+            "paths", metavar="PATH", nargs="*", type=str, help="paths to extract; patterns are supported"
+        )
         define_exclusion_group(subparser, strip_components=True)
 
         # borg help
-        subparser = subparsers.add_parser('help', parents=[common_parser], add_help=False,
-                                          description='Extra help')
-        subparser.add_argument('--epilog-only', dest='epilog_only', action='store_true')
-        subparser.add_argument('--usage-only', dest='usage_only', action='store_true')
+        subparser = subparsers.add_parser("help", parents=[common_parser], add_help=False, description="Extra help")
+        subparser.add_argument("--epilog-only", dest="epilog_only", action="store_true")
+        subparser.add_argument("--usage-only", dest="usage_only", action="store_true")
         subparser.set_defaults(func=functools.partial(self.do_help, parser, subparsers.choices))
-        subparser.add_argument('topic', metavar='TOPIC', type=str, nargs='?',
-                               help='additional help on TOPIC')
+        subparser.add_argument("topic", metavar="TOPIC", type=str, nargs="?", help="additional help on TOPIC")
 
         # borg rinfo
-        rinfo_epilog = process_epilog("""
+        rinfo_epilog = process_epilog(
+            """
         This command displays detailed information about the repository.
 
         Please note that the deduplicated sizes of the individual archives do not add
@@ -4207,18 +5053,23 @@ class Archiver:
         = unique chunks of this archive.
         All archives / deduplicated size = amount of data stored in the repo
         = all chunks in the repository.
-        """)
-        subparser = subparsers.add_parser('rinfo', parents=[common_parser], add_help=False,
-                                          description=self.do_rinfo.__doc__,
-                                          epilog=rinfo_epilog,
-                                          formatter_class=argparse.RawDescriptionHelpFormatter,
-                                          help='show repository information')
+        """
+        )
+        subparser = subparsers.add_parser(
+            "rinfo",
+            parents=[common_parser],
+            add_help=False,
+            description=self.do_rinfo.__doc__,
+            epilog=rinfo_epilog,
+            formatter_class=argparse.RawDescriptionHelpFormatter,
+            help="show repository information",
+        )
         subparser.set_defaults(func=self.do_rinfo)
-        subparser.add_argument('--json', action='store_true',
-                               help='format output as JSON')
+        subparser.add_argument("--json", action="store_true", help="format output as JSON")
 
         # borg info
-        info_epilog = process_epilog("""
+        info_epilog = process_epilog(
+            """
         This command displays detailed information about the specified archive.
 
         Please note that the deduplicated sizes of the individual archives do not add
@@ -4234,19 +5085,24 @@ class Archiver:
         The size of an archive relative to this limit depends on a number of factors,
         mainly the number of files, the lengths of paths and other metadata stored for files.
         This is shown as *utilization of maximum supported archive size*.
-        """)
-        subparser = subparsers.add_parser('info', parents=[common_parser], add_help=False,
-                                          description=self.do_info.__doc__,
-                                          epilog=info_epilog,
-                                          formatter_class=argparse.RawDescriptionHelpFormatter,
-                                          help='show repository or archive information')
+        """
+        )
+        subparser = subparsers.add_parser(
+            "info",
+            parents=[common_parser],
+            add_help=False,
+            description=self.do_info.__doc__,
+            epilog=info_epilog,
+            formatter_class=argparse.RawDescriptionHelpFormatter,
+            help="show repository or archive information",
+        )
         subparser.set_defaults(func=self.do_info)
-        subparser.add_argument('--json', action='store_true',
-                               help='format output as JSON')
+        subparser.add_argument("--json", action="store_true", help="format output as JSON")
         define_archive_filters_group(subparser)
 
         # borg rcreate
-        rcreate_epilog = process_epilog("""
+        rcreate_epilog = process_epilog(
+            """
         This command creates a new, empty repository. A repository is a filesystem
         directory containing the deduplicated data from zero or more archives.
 
@@ -4350,40 +5206,75 @@ class Archiver:
         If you do **not** want to encrypt the contents of your backups, but still want to detect
         malicious tampering use an `authenticated` mode. It's like `repokey` minus encryption.
 
-        """)
-        subparser = subparsers.add_parser('rcreate', parents=[common_parser], add_help=False,
-                                          description=self.do_rcreate.__doc__, epilog=rcreate_epilog,
-                                          formatter_class=argparse.RawDescriptionHelpFormatter,
-                                          help='create a new, empty repository')
+        """
+        )
+        subparser = subparsers.add_parser(
+            "rcreate",
+            parents=[common_parser],
+            add_help=False,
+            description=self.do_rcreate.__doc__,
+            epilog=rcreate_epilog,
+            formatter_class=argparse.RawDescriptionHelpFormatter,
+            help="create a new, empty repository",
+        )
         subparser.set_defaults(func=self.do_rcreate)
-        subparser.add_argument('--other-repo', metavar='SRC_REPOSITORY', dest='other_location',
-                               type=location_validator(other=True), default=Location(other=True),
-                               help='reuse the key material from the other repository')
-        subparser.add_argument('-e', '--encryption', metavar='MODE', dest='encryption', required=True,
-                               choices=key_argument_names(),
-                               help='select encryption key mode **(required)**')
-        subparser.add_argument('--append-only', dest='append_only', action='store_true',
-                               help='create an append-only mode repository. Note that this only affects '
-                                    'the low level structure of the repository, and running `delete` '
-                                    'or `prune` will still be allowed. See :ref:`append_only_mode` in '
-                                    'Additional Notes for more details.')
-        subparser.add_argument('--storage-quota', metavar='QUOTA', dest='storage_quota', default=None,
-                               type=parse_storage_quota,
-                               help='Set storage quota of the new repository (e.g. 5G, 1.5T). Default: no quota.')
-        subparser.add_argument('--make-parent-dirs', dest='make_parent_dirs', action='store_true',
-                               help='create the parent directories of the repository directory, if they are missing.')
+        subparser.add_argument(
+            "--other-repo",
+            metavar="SRC_REPOSITORY",
+            dest="other_location",
+            type=location_validator(other=True),
+            default=Location(other=True),
+            help="reuse the key material from the other repository",
+        )
+        subparser.add_argument(
+            "-e",
+            "--encryption",
+            metavar="MODE",
+            dest="encryption",
+            required=True,
+            choices=key_argument_names(),
+            help="select encryption key mode **(required)**",
+        )
+        subparser.add_argument(
+            "--append-only",
+            dest="append_only",
+            action="store_true",
+            help="create an append-only mode repository. Note that this only affects "
+            "the low level structure of the repository, and running `delete` "
+            "or `prune` will still be allowed. See :ref:`append_only_mode` in "
+            "Additional Notes for more details.",
+        )
+        subparser.add_argument(
+            "--storage-quota",
+            metavar="QUOTA",
+            dest="storage_quota",
+            default=None,
+            type=parse_storage_quota,
+            help="Set storage quota of the new repository (e.g. 5G, 1.5T). Default: no quota.",
+        )
+        subparser.add_argument(
+            "--make-parent-dirs",
+            dest="make_parent_dirs",
+            action="store_true",
+            help="create the parent directories of the repository directory, if they are missing.",
+        )
 
         # borg key
-        subparser = subparsers.add_parser('key', parents=[mid_common_parser], add_help=False,
-                                          description="Manage a keyfile or repokey of a repository",
-                                          epilog="",
-                                          formatter_class=argparse.RawDescriptionHelpFormatter,
-                                          help='manage repository key')
+        subparser = subparsers.add_parser(
+            "key",
+            parents=[mid_common_parser],
+            add_help=False,
+            description="Manage a keyfile or repokey of a repository",
+            epilog="",
+            formatter_class=argparse.RawDescriptionHelpFormatter,
+            help="manage repository key",
+        )
 
-        key_parsers = subparser.add_subparsers(title='required arguments', metavar='<command>')
+        key_parsers = subparser.add_subparsers(title="required arguments", metavar="<command>")
         subparser.set_defaults(fallback_func=functools.partial(self.do_subcommand_help, subparser))
 
-        key_export_epilog = process_epilog("""
+        key_export_epilog = process_epilog(
+            """
         If repository encryption is used, the repository is inaccessible
         without the key. This command allows one to backup this essential key.
         Note that the backup produced does not include the passphrase itself
@@ -4417,21 +5308,34 @@ class Archiver:
             borg key export --qr-html /path/to/repo encrypted-key-backup.html
 
 
-        """)
-        subparser = key_parsers.add_parser('export', parents=[common_parser], add_help=False,
-                                          description=self.do_key_export.__doc__,
-                                          epilog=key_export_epilog,
-                                          formatter_class=argparse.RawDescriptionHelpFormatter,
-                                          help='export repository key for backup')
+        """
+        )
+        subparser = key_parsers.add_parser(
+            "export",
+            parents=[common_parser],
+            add_help=False,
+            description=self.do_key_export.__doc__,
+            epilog=key_export_epilog,
+            formatter_class=argparse.RawDescriptionHelpFormatter,
+            help="export repository key for backup",
+        )
         subparser.set_defaults(func=self.do_key_export)
-        subparser.add_argument('path', metavar='PATH', nargs='?', type=str,
-                               help='where to store the backup')
-        subparser.add_argument('--paper', dest='paper', action='store_true',
-                               help='Create an export suitable for printing and later type-in')
-        subparser.add_argument('--qr-html', dest='qr', action='store_true',
-                               help='Create an html file suitable for printing and later type-in or qr scan')
+        subparser.add_argument("path", metavar="PATH", nargs="?", type=str, help="where to store the backup")
+        subparser.add_argument(
+            "--paper",
+            dest="paper",
+            action="store_true",
+            help="Create an export suitable for printing and later type-in",
+        )
+        subparser.add_argument(
+            "--qr-html",
+            dest="qr",
+            action="store_true",
+            help="Create an html file suitable for printing and later type-in or qr scan",
+        )
 
-        key_import_epilog = process_epilog("""
+        key_import_epilog = process_epilog(
+            """
         This command restores a key previously backed up with the export command.
 
         If the ``--paper`` option is given, the import will be an interactive
@@ -4446,19 +5350,30 @@ class Archiver:
         associated with the repository. If a key file is found in
         ``$BORG_KEYS_DIR``, ``borg key import`` overwrites it; otherwise, ``borg
         key import`` creates a new key file in ``$BORG_KEYS_DIR``.
-        """)
-        subparser = key_parsers.add_parser('import', parents=[common_parser], add_help=False,
-                                          description=self.do_key_import.__doc__,
-                                          epilog=key_import_epilog,
-                                          formatter_class=argparse.RawDescriptionHelpFormatter,
-                                          help='import repository key from backup')
+        """
+        )
+        subparser = key_parsers.add_parser(
+            "import",
+            parents=[common_parser],
+            add_help=False,
+            description=self.do_key_import.__doc__,
+            epilog=key_import_epilog,
+            formatter_class=argparse.RawDescriptionHelpFormatter,
+            help="import repository key from backup",
+        )
         subparser.set_defaults(func=self.do_key_import)
-        subparser.add_argument('path', metavar='PATH', nargs='?', type=str,
-                               help='path to the backup (\'-\' to read from stdin)')
-        subparser.add_argument('--paper', dest='paper', action='store_true',
-                               help='interactively import from a backup done with ``--paper``')
+        subparser.add_argument(
+            "path", metavar="PATH", nargs="?", type=str, help="path to the backup ('-' to read from stdin)"
+        )
+        subparser.add_argument(
+            "--paper",
+            dest="paper",
+            action="store_true",
+            help="interactively import from a backup done with ``--paper``",
+        )
 
-        change_passphrase_epilog = process_epilog("""
+        change_passphrase_epilog = process_epilog(
+            """
         The key files used for repository encryption are optionally passphrase
         protected. This command can be used to change this passphrase.
 
@@ -4466,15 +5381,21 @@ class Archiver:
         secret protected by it (like e.g. encryption/MAC keys or chunker seed).
         Thus, changing the passphrase after passphrase and borg key got compromised
         does not protect future (nor past) backups to the same repository.
-        """)
-        subparser = key_parsers.add_parser('change-passphrase', parents=[common_parser], add_help=False,
-                                          description=self.do_change_passphrase.__doc__,
-                                          epilog=change_passphrase_epilog,
-                                          formatter_class=argparse.RawDescriptionHelpFormatter,
-                                          help='change repository passphrase')
+        """
+        )
+        subparser = key_parsers.add_parser(
+            "change-passphrase",
+            parents=[common_parser],
+            add_help=False,
+            description=self.do_change_passphrase.__doc__,
+            epilog=change_passphrase_epilog,
+            formatter_class=argparse.RawDescriptionHelpFormatter,
+            help="change repository passphrase",
+        )
         subparser.set_defaults(func=self.do_change_passphrase)
 
-        change_location_epilog = process_epilog("""
+        change_location_epilog = process_epilog(
+            """
         Change the location of a borg key. The key can be stored at different locations:
 
         - keyfile: locally, usually in the home directory
@@ -4484,20 +5405,32 @@ class Archiver:
 
         This command does NOT change the crypto algorithms, just the key location,
         thus you must ONLY give the key location (keyfile or repokey).
-        """)
-        subparser = key_parsers.add_parser('change-location', parents=[common_parser], add_help=False,
-                                          description=self.do_change_location.__doc__,
-                                          epilog=change_location_epilog,
-                                          formatter_class=argparse.RawDescriptionHelpFormatter,
-                                          help='change key location')
+        """
+        )
+        subparser = key_parsers.add_parser(
+            "change-location",
+            parents=[common_parser],
+            add_help=False,
+            description=self.do_change_location.__doc__,
+            epilog=change_location_epilog,
+            formatter_class=argparse.RawDescriptionHelpFormatter,
+            help="change key location",
+        )
         subparser.set_defaults(func=self.do_change_location)
-        subparser.add_argument('key_mode', metavar='KEY_LOCATION', choices=('repokey', 'keyfile'),
-                               help='select key location')
-        subparser.add_argument('--keep', dest='keep', action='store_true',
-                               help='keep the key also at the current location (default: remove it)')
+        subparser.add_argument(
+            "key_mode", metavar="KEY_LOCATION", choices=("repokey", "keyfile"), help="select key location"
+        )
+        subparser.add_argument(
+            "--keep",
+            dest="keep",
+            action="store_true",
+            help="keep the key also at the current location (default: remove it)",
+        )
 
         # borg list
-        list_epilog = process_epilog("""
+        list_epilog = (
+            process_epilog(
+                """
         This command lists the contents of an archive.
 
         For more help on include/exclude patterns, see the :ref:`borg_patterns` command output.
@@ -4526,36 +5459,57 @@ class Archiver:
         The following keys are always available:
 
 
-        """) + BaseFormatter.keys_help() + textwrap.dedent("""
+        """
+            )
+            + BaseFormatter.keys_help()
+            + textwrap.dedent(
+                """
 
         Keys available only when listing files in an archive:
 
-        """) + ItemFormatter.keys_help()
-        subparser = subparsers.add_parser('list', parents=[common_parser], add_help=False,
-                                          description=self.do_list.__doc__,
-                                          epilog=list_epilog,
-                                          formatter_class=argparse.RawDescriptionHelpFormatter,
-                                          help='list archive contents')
+        """
+            )
+            + ItemFormatter.keys_help()
+        )
+        subparser = subparsers.add_parser(
+            "list",
+            parents=[common_parser],
+            add_help=False,
+            description=self.do_list.__doc__,
+            epilog=list_epilog,
+            formatter_class=argparse.RawDescriptionHelpFormatter,
+            help="list archive contents",
+        )
         subparser.set_defaults(func=self.do_list)
-        subparser.add_argument('--short', dest='short', action='store_true',
-                               help='only print file/directory names, nothing else')
-        subparser.add_argument('--format', metavar='FORMAT', dest='format',
-                               help='specify format for file listing '
-                                    '(default: "{mode} {user:6} {group:6} {size:8} {mtime} {path}{extra}{NL}")')
-        subparser.add_argument('--json-lines', action='store_true',
-                               help='Format output as JSON Lines. '
-                                    'The form of ``--format`` is ignored, '
-                                    'but keys used in it are added to the JSON output. '
-                                    'Some keys are always present. Note: JSON can only represent text. '
-                                    'A "bpath" key is therefore not available.')
-        subparser.add_argument('name', metavar='NAME', type=NameSpec,
-                               help='specify the archive name')
-        subparser.add_argument('paths', metavar='PATH', nargs='*', type=str,
-                               help='paths to list; patterns are supported')
+        subparser.add_argument(
+            "--short", dest="short", action="store_true", help="only print file/directory names, nothing else"
+        )
+        subparser.add_argument(
+            "--format",
+            metavar="FORMAT",
+            dest="format",
+            help="specify format for file listing "
+            '(default: "{mode} {user:6} {group:6} {size:8} {mtime} {path}{extra}{NL}")',
+        )
+        subparser.add_argument(
+            "--json-lines",
+            action="store_true",
+            help="Format output as JSON Lines. "
+            "The form of ``--format`` is ignored, "
+            "but keys used in it are added to the JSON output. "
+            "Some keys are always present. Note: JSON can only represent text. "
+            'A "bpath" key is therefore not available.',
+        )
+        subparser.add_argument("name", metavar="NAME", type=NameSpec, help="specify the archive name")
+        subparser.add_argument(
+            "paths", metavar="PATH", nargs="*", type=str, help="paths to list; patterns are supported"
+        )
         define_exclusion_group(subparser)
 
         # borg rlist
-        rlist_epilog = process_epilog("""
+        rlist_epilog = (
+            process_epilog(
+                """
         This command lists the archives contained in a repository.
 
         .. man NOTES
@@ -4584,41 +5538,68 @@ class Archiver:
         The following keys are always available:
 
 
-        """) + BaseFormatter.keys_help() + textwrap.dedent("""
+        """
+            )
+            + BaseFormatter.keys_help()
+            + textwrap.dedent(
+                """
 
         Keys available only when listing archives in a repository:
 
-        """) + ArchiveFormatter.keys_help()
-        subparser = subparsers.add_parser('rlist', parents=[common_parser], add_help=False,
-                                          description=self.do_rlist.__doc__,
-                                          epilog=rlist_epilog,
-                                          formatter_class=argparse.RawDescriptionHelpFormatter,
-                                          help='list repository contents')
+        """
+            )
+            + ArchiveFormatter.keys_help()
+        )
+        subparser = subparsers.add_parser(
+            "rlist",
+            parents=[common_parser],
+            add_help=False,
+            description=self.do_rlist.__doc__,
+            epilog=rlist_epilog,
+            formatter_class=argparse.RawDescriptionHelpFormatter,
+            help="list repository contents",
+        )
         subparser.set_defaults(func=self.do_rlist)
-        subparser.add_argument('--consider-checkpoints', action='store_true', dest='consider_checkpoints',
-                               help='Show checkpoint archives in the repository contents list (default: hidden).')
-        subparser.add_argument('--short', dest='short', action='store_true',
-                               help='only print the archive names, nothing else')
-        subparser.add_argument('--format', metavar='FORMAT', dest='format',
-                               help='specify format for archive listing '
-                                    '(default: "{archive:<36} {time} [{id}]{NL}")')
-        subparser.add_argument('--json', action='store_true',
-                               help='Format output as JSON. '
-                                    'The form of ``--format`` is ignored, '
-                                    'but keys used in it are added to the JSON output. '
-                                    'Some keys are always present. Note: JSON can only represent text. '
-                                    'A "barchive" key is therefore not available.')
+        subparser.add_argument(
+            "--consider-checkpoints",
+            action="store_true",
+            dest="consider_checkpoints",
+            help="Show checkpoint archives in the repository contents list (default: hidden).",
+        )
+        subparser.add_argument(
+            "--short", dest="short", action="store_true", help="only print the archive names, nothing else"
+        )
+        subparser.add_argument(
+            "--format",
+            metavar="FORMAT",
+            dest="format",
+            help="specify format for archive listing " '(default: "{archive:<36} {time} [{id}]{NL}")',
+        )
+        subparser.add_argument(
+            "--json",
+            action="store_true",
+            help="Format output as JSON. "
+            "The form of ``--format`` is ignored, "
+            "but keys used in it are added to the JSON output. "
+            "Some keys are always present. Note: JSON can only represent text. "
+            'A "barchive" key is therefore not available.',
+        )
         define_archive_filters_group(subparser)
 
-        subparser = subparsers.add_parser('mount', parents=[common_parser], add_help=False,
-                                        description=self.do_mount.__doc__,
-                                        epilog=mount_epilog,
-                                        formatter_class=argparse.RawDescriptionHelpFormatter,
-                                        help='mount repository')
+        subparser = subparsers.add_parser(
+            "mount",
+            parents=[common_parser],
+            add_help=False,
+            description=self.do_mount.__doc__,
+            epilog=mount_epilog,
+            formatter_class=argparse.RawDescriptionHelpFormatter,
+            help="mount repository",
+        )
         define_borg_mount(subparser)
 
         # borg prune
-        prune_epilog = process_epilog("""
+        prune_epilog = process_epilog(
+            """
         The prune command prunes a repository by deleting all archives not matching
         any of the specified retention options.
 
@@ -4672,44 +5653,72 @@ class Archiver:
         deleted - the "Deleted data" deduplicated size there is most interesting as
         that is how much your repository will shrink.
         Please note that the "All archives" stats refer to the state after pruning.
-        """)
-        subparser = subparsers.add_parser('prune', parents=[common_parser], add_help=False,
-                                          description=self.do_prune.__doc__,
-                                          epilog=prune_epilog,
-                                          formatter_class=argparse.RawDescriptionHelpFormatter,
-                                          help='prune archives')
+        """
+        )
+        subparser = subparsers.add_parser(
+            "prune",
+            parents=[common_parser],
+            add_help=False,
+            description=self.do_prune.__doc__,
+            epilog=prune_epilog,
+            formatter_class=argparse.RawDescriptionHelpFormatter,
+            help="prune archives",
+        )
         subparser.set_defaults(func=self.do_prune)
-        subparser.add_argument('-n', '--dry-run', dest='dry_run', action='store_true',
-                               help='do not change repository')
-        subparser.add_argument('--force', dest='forced', action='store_true',
-                               help='force pruning of corrupted archives, '
-                                    'use ``--force --force`` in case ``--force`` does not work.')
-        subparser.add_argument('-s', '--stats', dest='stats', action='store_true',
-                               help='print statistics for the deleted archive')
-        subparser.add_argument('--list', dest='output_list', action='store_true',
-                               help='output verbose list of archives it keeps/prunes')
-        subparser.add_argument('--keep-within', metavar='INTERVAL', dest='within', type=interval,
-                               help='keep all archives within this time interval')
-        subparser.add_argument('--keep-last', '--keep-secondly', dest='secondly', type=int, default=0,
-                               help='number of secondly archives to keep')
-        subparser.add_argument('--keep-minutely', dest='minutely', type=int, default=0,
-                               help='number of minutely archives to keep')
-        subparser.add_argument('-H', '--keep-hourly', dest='hourly', type=int, default=0,
-                               help='number of hourly archives to keep')
-        subparser.add_argument('-d', '--keep-daily', dest='daily', type=int, default=0,
-                               help='number of daily archives to keep')
-        subparser.add_argument('-w', '--keep-weekly', dest='weekly', type=int, default=0,
-                               help='number of weekly archives to keep')
-        subparser.add_argument('-m', '--keep-monthly', dest='monthly', type=int, default=0,
-                               help='number of monthly archives to keep')
-        subparser.add_argument('-y', '--keep-yearly', dest='yearly', type=int, default=0,
-                               help='number of yearly archives to keep')
+        subparser.add_argument("-n", "--dry-run", dest="dry_run", action="store_true", help="do not change repository")
+        subparser.add_argument(
+            "--force",
+            dest="forced",
+            action="store_true",
+            help="force pruning of corrupted archives, " "use ``--force --force`` in case ``--force`` does not work.",
+        )
+        subparser.add_argument(
+            "-s", "--stats", dest="stats", action="store_true", help="print statistics for the deleted archive"
+        )
+        subparser.add_argument(
+            "--list", dest="output_list", action="store_true", help="output verbose list of archives it keeps/prunes"
+        )
+        subparser.add_argument(
+            "--keep-within",
+            metavar="INTERVAL",
+            dest="within",
+            type=interval,
+            help="keep all archives within this time interval",
+        )
+        subparser.add_argument(
+            "--keep-last",
+            "--keep-secondly",
+            dest="secondly",
+            type=int,
+            default=0,
+            help="number of secondly archives to keep",
+        )
+        subparser.add_argument(
+            "--keep-minutely", dest="minutely", type=int, default=0, help="number of minutely archives to keep"
+        )
+        subparser.add_argument(
+            "-H", "--keep-hourly", dest="hourly", type=int, default=0, help="number of hourly archives to keep"
+        )
+        subparser.add_argument(
+            "-d", "--keep-daily", dest="daily", type=int, default=0, help="number of daily archives to keep"
+        )
+        subparser.add_argument(
+            "-w", "--keep-weekly", dest="weekly", type=int, default=0, help="number of weekly archives to keep"
+        )
+        subparser.add_argument(
+            "-m", "--keep-monthly", dest="monthly", type=int, default=0, help="number of monthly archives to keep"
+        )
+        subparser.add_argument(
+            "-y", "--keep-yearly", dest="yearly", type=int, default=0, help="number of yearly archives to keep"
+        )
         define_archive_filters_group(subparser, sort_by=False, first_last=False)
-        subparser.add_argument('--save-space', dest='save_space', action='store_true',
-                               help='work slower, but using less space')
+        subparser.add_argument(
+            "--save-space", dest="save_space", action="store_true", help="work slower, but using less space"
+        )
 
         # borg recreate
-        recreate_epilog = process_epilog("""
+        recreate_epilog = process_epilog(
+            """
         Recreate the contents of existing archives.
 
         recreate is a potentially dangerous function and might lead to data loss
@@ -4760,131 +5769,219 @@ class Archiver:
         any more after re-chunking (it is also unlikely it would ever work: due to the
         change of chunking parameters, the missing chunk likely will never be seen again
         even if you still have the data that produced it).
-        """)
-        subparser = subparsers.add_parser('recreate', parents=[common_parser], add_help=False,
-                                          description=self.do_recreate.__doc__,
-                                          epilog=recreate_epilog,
-                                          formatter_class=argparse.RawDescriptionHelpFormatter,
-                                          help=self.do_recreate.__doc__)
+        """
+        )
+        subparser = subparsers.add_parser(
+            "recreate",
+            parents=[common_parser],
+            add_help=False,
+            description=self.do_recreate.__doc__,
+            epilog=recreate_epilog,
+            formatter_class=argparse.RawDescriptionHelpFormatter,
+            help=self.do_recreate.__doc__,
+        )
         subparser.set_defaults(func=self.do_recreate)
-        subparser.add_argument('--list', dest='output_list', action='store_true',
-                               help='output verbose list of items (files, dirs, ...)')
-        subparser.add_argument('--filter', metavar='STATUSCHARS', dest='output_filter', action=Highlander,
-                               help='only display items with the given status characters (listed in borg create --help)')
-        subparser.add_argument('-n', '--dry-run', dest='dry_run', action='store_true',
-                               help='do not change anything')
-        subparser.add_argument('-s', '--stats', dest='stats', action='store_true',
-                               help='print statistics at end')
+        subparser.add_argument(
+            "--list", dest="output_list", action="store_true", help="output verbose list of items (files, dirs, ...)"
+        )
+        subparser.add_argument(
+            "--filter",
+            metavar="STATUSCHARS",
+            dest="output_filter",
+            action=Highlander,
+            help="only display items with the given status characters (listed in borg create --help)",
+        )
+        subparser.add_argument("-n", "--dry-run", dest="dry_run", action="store_true", help="do not change anything")
+        subparser.add_argument("-s", "--stats", dest="stats", action="store_true", help="print statistics at end")
 
         define_exclusion_group(subparser, tag_files=True)
 
         archive_group = define_archive_filters_group(subparser)
-        archive_group.add_argument('--target', dest='target', metavar='TARGET', default=None,
-                                   type=archivename_validator(),
-                                   help='create a new archive with the name ARCHIVE, do not replace existing archive '
-                                        '(only applies for a single archive)')
-        archive_group.add_argument('-c', '--checkpoint-interval', dest='checkpoint_interval',
-                                   type=int, default=1800, metavar='SECONDS',
-                                   help='write checkpoint every SECONDS seconds (Default: 1800)')
-        archive_group.add_argument('--comment', dest='comment', metavar='COMMENT', type=CommentSpec, default=None,
-                                   help='add a comment text to the archive')
-        archive_group.add_argument('--timestamp', metavar='TIMESTAMP', dest='timestamp',
-                                   type=timestamp, default=None,
-                                   help='manually specify the archive creation date/time (UTC, yyyy-mm-ddThh:mm:ss format). '
-                                        'alternatively, give a reference file/directory.')
-        archive_group.add_argument('-C', '--compression', metavar='COMPRESSION', dest='compression',
-                                   type=CompressionSpec, default=CompressionSpec('lz4'),
-                                   help='select compression algorithm, see the output of the '
-                                        '"borg help compression" command for details.')
-        archive_group.add_argument('--recompress', metavar='MODE', dest='recompress', nargs='?',
-                                   default='never', const='if-different', choices=('never', 'if-different', 'always'),
-                                   help='recompress data chunks according to `MODE` and ``--compression``. '
-                                        'Possible modes are '
-                                        '`if-different`: recompress if current compression is with a different '
-                                        'compression algorithm or different level; '
-                                        '`always`: recompress unconditionally; and '
-                                        '`never`: do not recompress (use this option to explicitly prevent '
-                                        'recompression). '
-                                        'If no MODE is given, `if-different` will be used. '
-                                        'Not passing --recompress is equivalent to "--recompress never".')
-        archive_group.add_argument('--chunker-params', metavar='PARAMS', dest='chunker_params', action=Highlander,
-                                   type=ChunkerParams, default=CHUNKER_PARAMS,
-                                   help='specify the chunker parameters (ALGO, CHUNK_MIN_EXP, CHUNK_MAX_EXP, '
-                                        'HASH_MASK_BITS, HASH_WINDOW_SIZE) or `default` to use the current defaults. '
-                                        'default: %s,%d,%d,%d,%d' % CHUNKER_PARAMS)
+        archive_group.add_argument(
+            "--target",
+            dest="target",
+            metavar="TARGET",
+            default=None,
+            type=archivename_validator(),
+            help="create a new archive with the name ARCHIVE, do not replace existing archive "
+            "(only applies for a single archive)",
+        )
+        archive_group.add_argument(
+            "-c",
+            "--checkpoint-interval",
+            dest="checkpoint_interval",
+            type=int,
+            default=1800,
+            metavar="SECONDS",
+            help="write checkpoint every SECONDS seconds (Default: 1800)",
+        )
+        archive_group.add_argument(
+            "--comment",
+            dest="comment",
+            metavar="COMMENT",
+            type=CommentSpec,
+            default=None,
+            help="add a comment text to the archive",
+        )
+        archive_group.add_argument(
+            "--timestamp",
+            metavar="TIMESTAMP",
+            dest="timestamp",
+            type=timestamp,
+            default=None,
+            help="manually specify the archive creation date/time (UTC, yyyy-mm-ddThh:mm:ss format). "
+            "alternatively, give a reference file/directory.",
+        )
+        archive_group.add_argument(
+            "-C",
+            "--compression",
+            metavar="COMPRESSION",
+            dest="compression",
+            type=CompressionSpec,
+            default=CompressionSpec("lz4"),
+            help="select compression algorithm, see the output of the " '"borg help compression" command for details.',
+        )
+        archive_group.add_argument(
+            "--recompress",
+            metavar="MODE",
+            dest="recompress",
+            nargs="?",
+            default="never",
+            const="if-different",
+            choices=("never", "if-different", "always"),
+            help="recompress data chunks according to `MODE` and ``--compression``. "
+            "Possible modes are "
+            "`if-different`: recompress if current compression is with a different "
+            "compression algorithm or different level; "
+            "`always`: recompress unconditionally; and "
+            "`never`: do not recompress (use this option to explicitly prevent "
+            "recompression). "
+            "If no MODE is given, `if-different` will be used. "
+            'Not passing --recompress is equivalent to "--recompress never".',
+        )
+        archive_group.add_argument(
+            "--chunker-params",
+            metavar="PARAMS",
+            dest="chunker_params",
+            action=Highlander,
+            type=ChunkerParams,
+            default=CHUNKER_PARAMS,
+            help="specify the chunker parameters (ALGO, CHUNK_MIN_EXP, CHUNK_MAX_EXP, "
+            "HASH_MASK_BITS, HASH_WINDOW_SIZE) or `default` to use the current defaults. "
+            "default: %s,%d,%d,%d,%d" % CHUNKER_PARAMS,
+        )
 
-        subparser.add_argument('paths', metavar='PATH', nargs='*', type=str,
-                               help='paths to recreate; patterns are supported')
+        subparser.add_argument(
+            "paths", metavar="PATH", nargs="*", type=str, help="paths to recreate; patterns are supported"
+        )
 
         # borg rename
-        rename_epilog = process_epilog("""
+        rename_epilog = process_epilog(
+            """
         This command renames an archive in the repository.
 
         This results in a different archive ID.
-        """)
-        subparser = subparsers.add_parser('rename', parents=[common_parser], add_help=False,
-                                          description=self.do_rename.__doc__,
-                                          epilog=rename_epilog,
-                                          formatter_class=argparse.RawDescriptionHelpFormatter,
-                                          help='rename archive')
+        """
+        )
+        subparser = subparsers.add_parser(
+            "rename",
+            parents=[common_parser],
+            add_help=False,
+            description=self.do_rename.__doc__,
+            epilog=rename_epilog,
+            formatter_class=argparse.RawDescriptionHelpFormatter,
+            help="rename archive",
+        )
         subparser.set_defaults(func=self.do_rename)
-        subparser.add_argument('name', metavar='OLDNAME',
-                               type=archivename_validator(),
-                               help='specify the archive name')
-        subparser.add_argument('newname', metavar='NEWNAME',
-                               type=archivename_validator(),
-                               help='specify the new archive name')
+        subparser.add_argument("name", metavar="OLDNAME", type=archivename_validator(), help="specify the archive name")
+        subparser.add_argument(
+            "newname", metavar="NEWNAME", type=archivename_validator(), help="specify the new archive name"
+        )
 
         # borg serve
-        serve_epilog = process_epilog("""
+        serve_epilog = process_epilog(
+            """
         This command starts a repository server process. This command is usually not used manually.
-        """)
-        subparser = subparsers.add_parser('serve', parents=[common_parser], add_help=False,
-                                          description=self.do_serve.__doc__, epilog=serve_epilog,
-                                          formatter_class=argparse.RawDescriptionHelpFormatter,
-                                          help='start repository server process')
+        """
+        )
+        subparser = subparsers.add_parser(
+            "serve",
+            parents=[common_parser],
+            add_help=False,
+            description=self.do_serve.__doc__,
+            epilog=serve_epilog,
+            formatter_class=argparse.RawDescriptionHelpFormatter,
+            help="start repository server process",
+        )
         subparser.set_defaults(func=self.do_serve)
-        subparser.add_argument('--restrict-to-path', metavar='PATH', dest='restrict_to_paths', action='append',
-                               help='restrict repository access to PATH. '
-                                    'Can be specified multiple times to allow the client access to several directories. '
-                                    'Access to all sub-directories is granted implicitly; PATH doesn\'t need to directly point to a repository.')
-        subparser.add_argument('--restrict-to-repository', metavar='PATH', dest='restrict_to_repositories', action='append',
-                                help='restrict repository access. Only the repository located at PATH '
-                                     '(no sub-directories are considered) is accessible. '
-                                     'Can be specified multiple times to allow the client access to several repositories. '
-                                     'Unlike ``--restrict-to-path`` sub-directories are not accessible; '
-                                     'PATH needs to directly point at a repository location. '
-                                     'PATH may be an empty directory or the last element of PATH may not exist, in which case '
-                                     'the client may initialize a repository there.')
-        subparser.add_argument('--append-only', dest='append_only', action='store_true',
-                               help='only allow appending to repository segment files. Note that this only '
-                                    'affects the low level structure of the repository, and running `delete` '
-                                    'or `prune` will still be allowed. See :ref:`append_only_mode` in Additional '
-                                    'Notes for more details.')
-        subparser.add_argument('--storage-quota', metavar='QUOTA', dest='storage_quota',
-                               type=parse_storage_quota, default=None,
-                               help='Override storage quota of the repository (e.g. 5G, 1.5T). '
-                                    'When a new repository is initialized, sets the storage quota on the new '
-                                    'repository as well. Default: no quota.')
+        subparser.add_argument(
+            "--restrict-to-path",
+            metavar="PATH",
+            dest="restrict_to_paths",
+            action="append",
+            help="restrict repository access to PATH. "
+            "Can be specified multiple times to allow the client access to several directories. "
+            "Access to all sub-directories is granted implicitly; PATH doesn't need to directly point to a repository.",
+        )
+        subparser.add_argument(
+            "--restrict-to-repository",
+            metavar="PATH",
+            dest="restrict_to_repositories",
+            action="append",
+            help="restrict repository access. Only the repository located at PATH "
+            "(no sub-directories are considered) is accessible. "
+            "Can be specified multiple times to allow the client access to several repositories. "
+            "Unlike ``--restrict-to-path`` sub-directories are not accessible; "
+            "PATH needs to directly point at a repository location. "
+            "PATH may be an empty directory or the last element of PATH may not exist, in which case "
+            "the client may initialize a repository there.",
+        )
+        subparser.add_argument(
+            "--append-only",
+            dest="append_only",
+            action="store_true",
+            help="only allow appending to repository segment files. Note that this only "
+            "affects the low level structure of the repository, and running `delete` "
+            "or `prune` will still be allowed. See :ref:`append_only_mode` in Additional "
+            "Notes for more details.",
+        )
+        subparser.add_argument(
+            "--storage-quota",
+            metavar="QUOTA",
+            dest="storage_quota",
+            type=parse_storage_quota,
+            default=None,
+            help="Override storage quota of the repository (e.g. 5G, 1.5T). "
+            "When a new repository is initialized, sets the storage quota on the new "
+            "repository as well. Default: no quota.",
+        )
 
         # borg umount
-        umount_epilog = process_epilog("""
+        umount_epilog = process_epilog(
+            """
         This command un-mounts a FUSE filesystem that was mounted with ``borg mount``.
 
         This is a convenience wrapper that just calls the platform-specific shell
         command - usually this is either umount or fusermount -u.
-        """)
-        subparser = subparsers.add_parser('umount', parents=[common_parser], add_help=False,
-                                          description=self.do_umount.__doc__,
-                                          epilog=umount_epilog,
-                                          formatter_class=argparse.RawDescriptionHelpFormatter,
-                                          help='umount repository')
+        """
+        )
+        subparser = subparsers.add_parser(
+            "umount",
+            parents=[common_parser],
+            add_help=False,
+            description=self.do_umount.__doc__,
+            epilog=umount_epilog,
+            formatter_class=argparse.RawDescriptionHelpFormatter,
+            help="umount repository",
+        )
         subparser.set_defaults(func=self.do_umount)
-        subparser.add_argument('mountpoint', metavar='MOUNTPOINT', type=str,
-                               help='mountpoint of the filesystem to umount')
+        subparser.add_argument(
+            "mountpoint", metavar="MOUNTPOINT", type=str, help="mountpoint of the filesystem to umount"
+        )
 
         # borg with-lock
-        with_lock_epilog = process_epilog("""
+        with_lock_epilog = process_epilog(
+            """
         This command runs a user-specified command while the repository lock is held.
 
         It will first try to acquire the lock (make sure that no other operation is
@@ -4898,20 +5995,24 @@ class Archiver:
             the copy. Thus, before using borg on the copy from a different host,
             you need to use "borg break-lock" on the copied repository, because
             Borg is cautious and does not automatically remove stale locks made by a different host.
-        """)
-        subparser = subparsers.add_parser('with-lock', parents=[common_parser], add_help=False,
-                                          description=self.do_with_lock.__doc__,
-                                          epilog=with_lock_epilog,
-                                          formatter_class=argparse.RawDescriptionHelpFormatter,
-                                          help='run user command with lock held')
+        """
+        )
+        subparser = subparsers.add_parser(
+            "with-lock",
+            parents=[common_parser],
+            add_help=False,
+            description=self.do_with_lock.__doc__,
+            epilog=with_lock_epilog,
+            formatter_class=argparse.RawDescriptionHelpFormatter,
+            help="run user command with lock held",
+        )
         subparser.set_defaults(func=self.do_with_lock)
-        subparser.add_argument('command', metavar='COMMAND',
-                               help='command to run')
-        subparser.add_argument('args', metavar='ARGS', nargs=argparse.REMAINDER,
-                               help='command arguments')
+        subparser.add_argument("command", metavar="COMMAND", help="command to run")
+        subparser.add_argument("args", metavar="ARGS", nargs=argparse.REMAINDER, help="command arguments")
 
         # borg import-tar
-        import_tar_epilog = process_epilog("""
+        import_tar_epilog = process_epilog(
+            """
         This command creates a backup archive from a tarball.
 
         When giving '-' as path, Borg will read a tar stream from standard input.
@@ -4945,51 +6046,93 @@ class Archiver:
         - UNIX V7 tar
         - SunOS tar with extended attributes
 
-        """)
-        subparser = subparsers.add_parser('import-tar', parents=[common_parser], add_help=False,
-                                          description=self.do_import_tar.__doc__,
-                                          epilog=import_tar_epilog,
-                                          formatter_class=argparse.RawDescriptionHelpFormatter,
-                                          help=self.do_import_tar.__doc__)
+        """
+        )
+        subparser = subparsers.add_parser(
+            "import-tar",
+            parents=[common_parser],
+            add_help=False,
+            description=self.do_import_tar.__doc__,
+            epilog=import_tar_epilog,
+            formatter_class=argparse.RawDescriptionHelpFormatter,
+            help=self.do_import_tar.__doc__,
+        )
         subparser.set_defaults(func=self.do_import_tar)
-        subparser.add_argument('--tar-filter', dest='tar_filter', default='auto', action=Highlander,
-                               help='filter program to pipe data through')
-        subparser.add_argument('-s', '--stats', dest='stats',
-                               action='store_true', default=False,
-                               help='print statistics for the created archive')
-        subparser.add_argument('--list', dest='output_list',
-                               action='store_true', default=False,
-                               help='output verbose list of items (files, dirs, ...)')
-        subparser.add_argument('--filter', dest='output_filter', metavar='STATUSCHARS', action=Highlander,
-                               help='only display items with the given status characters')
-        subparser.add_argument('--json', action='store_true',
-                               help='output stats as JSON (implies --stats)')
+        subparser.add_argument(
+            "--tar-filter",
+            dest="tar_filter",
+            default="auto",
+            action=Highlander,
+            help="filter program to pipe data through",
+        )
+        subparser.add_argument(
+            "-s",
+            "--stats",
+            dest="stats",
+            action="store_true",
+            default=False,
+            help="print statistics for the created archive",
+        )
+        subparser.add_argument(
+            "--list",
+            dest="output_list",
+            action="store_true",
+            default=False,
+            help="output verbose list of items (files, dirs, ...)",
+        )
+        subparser.add_argument(
+            "--filter",
+            dest="output_filter",
+            metavar="STATUSCHARS",
+            action=Highlander,
+            help="only display items with the given status characters",
+        )
+        subparser.add_argument("--json", action="store_true", help="output stats as JSON (implies --stats)")
 
-        archive_group = subparser.add_argument_group('Archive options')
-        archive_group.add_argument('--comment', dest='comment', metavar='COMMENT', default='',
-                                   help='add a comment text to the archive')
-        archive_group.add_argument('--timestamp', dest='timestamp',
-                                   type=timestamp, default=None,
-                                   metavar='TIMESTAMP',
-                                   help='manually specify the archive creation date/time (UTC, yyyy-mm-ddThh:mm:ss format). '
-                                        'alternatively, give a reference file/directory.')
-        archive_group.add_argument('-c', '--checkpoint-interval', dest='checkpoint_interval',
-                                   type=int, default=1800, metavar='SECONDS',
-                                   help='write checkpoint every SECONDS seconds (Default: 1800)')
-        archive_group.add_argument('--chunker-params', dest='chunker_params', action=Highlander,
-                                   type=ChunkerParams, default=CHUNKER_PARAMS,
-                                   metavar='PARAMS',
-                                   help='specify the chunker parameters (ALGO, CHUNK_MIN_EXP, CHUNK_MAX_EXP, '
-                                        'HASH_MASK_BITS, HASH_WINDOW_SIZE). default: %s,%d,%d,%d,%d' % CHUNKER_PARAMS)
-        archive_group.add_argument('-C', '--compression', metavar='COMPRESSION', dest='compression',
-                                   type=CompressionSpec, default=CompressionSpec('lz4'),
-                                   help='select compression algorithm, see the output of the '
-                                        '"borg help compression" command for details.')
+        archive_group = subparser.add_argument_group("Archive options")
+        archive_group.add_argument(
+            "--comment", dest="comment", metavar="COMMENT", default="", help="add a comment text to the archive"
+        )
+        archive_group.add_argument(
+            "--timestamp",
+            dest="timestamp",
+            type=timestamp,
+            default=None,
+            metavar="TIMESTAMP",
+            help="manually specify the archive creation date/time (UTC, yyyy-mm-ddThh:mm:ss format). "
+            "alternatively, give a reference file/directory.",
+        )
+        archive_group.add_argument(
+            "-c",
+            "--checkpoint-interval",
+            dest="checkpoint_interval",
+            type=int,
+            default=1800,
+            metavar="SECONDS",
+            help="write checkpoint every SECONDS seconds (Default: 1800)",
+        )
+        archive_group.add_argument(
+            "--chunker-params",
+            dest="chunker_params",
+            action=Highlander,
+            type=ChunkerParams,
+            default=CHUNKER_PARAMS,
+            metavar="PARAMS",
+            help="specify the chunker parameters (ALGO, CHUNK_MIN_EXP, CHUNK_MAX_EXP, "
+            "HASH_MASK_BITS, HASH_WINDOW_SIZE). default: %s,%d,%d,%d,%d" % CHUNKER_PARAMS,
+        )
+        archive_group.add_argument(
+            "-C",
+            "--compression",
+            metavar="COMPRESSION",
+            dest="compression",
+            type=CompressionSpec,
+            default=CompressionSpec("lz4"),
+            help="select compression algorithm, see the output of the " '"borg help compression" command for details.',
+        )
 
-        subparser.add_argument('name', metavar='NAME', type=NameSpec,
-                               help='specify the archive name')
-        subparser.add_argument('tarfile', metavar='TARFILE',
-                               help='input tar file. "-" to read from stdin instead.')
+        subparser.add_argument("name", metavar="NAME", type=NameSpec, help="specify the archive name")
+        subparser.add_argument("tarfile", metavar="TARFILE", help='input tar file. "-" to read from stdin instead.')
         return parser
 
     def get_args(self, argv, cmd):
@@ -5003,7 +6146,7 @@ class Archiver:
             client_argv = shlex.split(cmd)
             # Drop environment variables (do *not* interpret them) before trying to parse
             # the borg command line.
-            client_argv = list(itertools.dropwhile(lambda arg: '=' in arg, client_argv))
+            client_argv = list(itertools.dropwhile(lambda arg: "=" in arg, client_argv))
             client_result = self.parse_args(client_argv[1:])
             if client_result.func == result.func:
                 # make sure we only process like normal if the client is executing
@@ -5012,21 +6155,11 @@ class Archiver:
                 # client is allowed to specify the allowlisted options,
                 # everything else comes from the forced "borg serve" command (or the defaults).
                 # stuff from denylist must never be used from the client.
-                denylist = {
-                    'restrict_to_paths',
-                    'restrict_to_repositories',
-                    'append_only',
-                    'storage_quota',
-                    'umask',
-                }
-                allowlist = {
-                    'debug_topics',
-                    'lock_wait',
-                    'log_level',
-                }
+                denylist = {"restrict_to_paths", "restrict_to_repositories", "append_only", "storage_quota", "umask"}
+                allowlist = {"debug_topics", "lock_wait", "log_level"}
                 not_present = object()
                 for attr_name in allowlist:
-                    assert attr_name not in denylist, 'allowlist has denylisted attribute name %s' % attr_name
+                    assert attr_name not in denylist, "allowlist has denylisted attribute name %s" % attr_name
                     value = getattr(client_result, attr_name, not_present)
                     if value is not not_present:
                         # note: it is not possible to specify a allowlisted option via a forced command,
@@ -5040,24 +6173,34 @@ class Archiver:
         if args:
             args = self.preprocess_args(args)
         parser = self.build_parser()
-        args = parser.parse_args(args or ['-h'])
+        args = parser.parse_args(args or ["-h"])
         parser.common_options.resolve(args)
         func = get_func(args)
         if func == self.do_create and args.paths and args.paths_from_stdin:
-            parser.error('Must not pass PATH with ``--paths-from-stdin``.')
+            parser.error("Must not pass PATH with ``--paths-from-stdin``.")
         if func == self.do_create and not args.paths:
             if args.content_from_command or args.paths_from_command:
-                parser.error('No command given.')
+                parser.error("No command given.")
             elif not args.paths_from_stdin:
                 # need at least 1 path but args.paths may also be populated from patterns
-                parser.error('Need at least one PATH argument.')
-        if not getattr(args, 'lock', True):  # Option --bypass-lock sets args.lock = False
-            bypass_allowed = {self.do_check, self.do_config, self.do_diff,
-                              self.do_export_tar, self.do_extract, self.do_info, self.do_rinfo,
-                              self.do_list, self.do_rlist, self.do_mount, self.do_umount}
+                parser.error("Need at least one PATH argument.")
+        if not getattr(args, "lock", True):  # Option --bypass-lock sets args.lock = False
+            bypass_allowed = {
+                self.do_check,
+                self.do_config,
+                self.do_diff,
+                self.do_export_tar,
+                self.do_extract,
+                self.do_info,
+                self.do_rinfo,
+                self.do_list,
+                self.do_rlist,
+                self.do_mount,
+                self.do_umount,
+            }
             if func not in bypass_allowed:
-                raise Error('Not allowed to bypass locking mechanism for chosen command')
-        if getattr(args, 'timestamp', None):
+                raise Error("Not allowed to bypass locking mechanism for chosen command")
+        if getattr(args, "timestamp", None):
             args.location = args.location.with_timestamp(args.timestamp)
         return args
 
@@ -5069,26 +6212,26 @@ class Archiver:
         selftest(logger)
 
     def _setup_implied_logging(self, args):
-        """ turn on INFO level logging for args that imply that they will produce output """
+        """turn on INFO level logging for args that imply that they will produce output"""
         # map of option name to name of logger for that option
         option_logger = {
-            'output_list': 'borg.output.list',
-            'show_version': 'borg.output.show-version',
-            'show_rc': 'borg.output.show-rc',
-            'stats': 'borg.output.stats',
-            'progress': 'borg.output.progress',
+            "output_list": "borg.output.list",
+            "show_version": "borg.output.show-version",
+            "show_rc": "borg.output.show-rc",
+            "stats": "borg.output.stats",
+            "progress": "borg.output.progress",
         }
         for option, logger_name in option_logger.items():
             option_set = args.get(option, False)
-            logging.getLogger(logger_name).setLevel('INFO' if option_set else 'WARN')
+            logging.getLogger(logger_name).setLevel("INFO" if option_set else "WARN")
 
     def _setup_topic_debugging(self, args):
         """Turn on DEBUG level logging for specified --debug-topics."""
         for topic in args.debug_topics:
-            if '.' not in topic:
-                topic = 'borg.debug.' + topic
-            logger.debug('Enabling debug topic %s', topic)
-            logging.getLogger(topic).setLevel('DEBUG')
+            if "." not in topic:
+                topic = "borg.debug." + topic
+            logger.debug("Enabling debug topic %s", topic)
+            logging.getLogger(topic).setLevel("DEBUG")
 
     def run(self, args):
         os.umask(args.umask)  # early, before opening files
@@ -5101,13 +6244,13 @@ class Archiver:
         args.progress |= is_serve
         self._setup_implied_logging(vars(args))
         self._setup_topic_debugging(args)
-        if getattr(args, 'stats', False) and getattr(args, 'dry_run', False):
+        if getattr(args, "stats", False) and getattr(args, "dry_run", False):
             # the data needed for --stats is not computed when using --dry-run, so we can't do it.
             # for ease of scripting, we just ignore --stats when given with --dry-run.
             logger.warning("Ignoring --stats. It is not supported when using --dry-run.")
             args.stats = False
         if args.show_version:
-            logging.getLogger('borg.output.show-version').info('borgbackup version %s' % __version__)
+            logging.getLogger("borg.output.show-version").info("borgbackup version %s" % __version__)
         self.prerun_checks(logger, is_serve)
         if not is_supported_msgpack():
             logger.error("You do not have a supported version of the msgpack python package installed. Terminating.")
@@ -5120,10 +6263,11 @@ class Archiver:
             # Import only when needed - avoids a further increase in startup time
             import cProfile
             import marshal
-            logger.debug('Writing execution profile to %s', args.debug_profile)
+
+            logger.debug("Writing execution profile to %s", args.debug_profile)
             # Open the file early, before running the main program, to avoid
             # a very late crash in case the specified path is invalid.
-            with open(args.debug_profile, 'wb') as fd:
+            with open(args.debug_profile, "wb") as fd:
                 profiler = cProfile.Profile()
                 variables = dict(locals())
                 profiler.enable()
@@ -5132,7 +6276,7 @@ class Archiver:
                 finally:
                     profiler.disable()
                     profiler.snapshot_stats()
-                    if args.debug_profile.endswith('.pyprof'):
+                    if args.debug_profile.endswith(".pyprof"):
                         marshal.dump(profiler.stats, fd)
                     else:
                         # We use msgpack here instead of the marshal module used by cProfile itself,
@@ -5153,19 +6297,19 @@ def sig_info_handler(sig_no, stack):  # pragma: no cover
     with signal_handler(sig_no, signal.SIG_IGN):
         for frame in inspect.getouterframes(stack):
             func, loc = frame[3], frame[0].f_locals
-            if func in ('process_file', '_rec_walk', ):  # create op
-                path = loc['path']
+            if func in ("process_file", "_rec_walk"):  # create op
+                path = loc["path"]
                 try:
-                    pos = loc['fd'].tell()
-                    total = loc['st'].st_size
+                    pos = loc["fd"].tell()
+                    total = loc["st"].st_size
                 except Exception:
                     pos, total = 0, 0
                 logger.info(f"{path} {format_file_size(pos)}/{format_file_size(total)}")
                 break
-            if func in ('extract_item', ):  # extract op
-                path = loc['item'].path
+            if func in ("extract_item",):  # extract op
+                path = loc["item"].path
                 try:
-                    pos = loc['fd'].tell()
+                    pos = loc["fd"].tell()
                 except Exception:
                     pos = 0
                 logger.info(f"{path} {format_file_size(pos)}/???")
@@ -5173,15 +6317,15 @@ def sig_info_handler(sig_no, stack):  # pragma: no cover
 
 
 def sig_trace_handler(sig_no, stack):  # pragma: no cover
-    print('\nReceived SIGUSR2 at %s, dumping trace...' % datetime.now().replace(microsecond=0), file=sys.stderr)
+    print("\nReceived SIGUSR2 at %s, dumping trace..." % datetime.now().replace(microsecond=0), file=sys.stderr)
     faulthandler.dump_traceback()
 
 
 def main():  # pragma: no cover
     # Make sure stdout and stderr have errors='replace' to avoid unicode
     # issues when print()-ing unicode file names
-    sys.stdout = ErrorIgnoringTextIOWrapper(sys.stdout.buffer, sys.stdout.encoding, 'replace', line_buffering=True)
-    sys.stderr = ErrorIgnoringTextIOWrapper(sys.stderr.buffer, sys.stderr.encoding, 'replace', line_buffering=True)
+    sys.stdout = ErrorIgnoringTextIOWrapper(sys.stdout.buffer, sys.stdout.encoding, "replace", line_buffering=True)
+    sys.stderr = ErrorIgnoringTextIOWrapper(sys.stderr.buffer, sys.stderr.encoding, "replace", line_buffering=True)
 
     # If we receive SIGINT (ctrl-c), SIGTERM (kill) or SIGHUP (kill -HUP),
     # catch them and raise a proper exception that can be handled for an
@@ -5192,21 +6336,24 @@ def main():  # pragma: no cover
 
     # Register fault handler for SIGSEGV, SIGFPE, SIGABRT, SIGBUS and SIGILL.
     faulthandler.enable()
-    with signal_handler('SIGINT', raising_signal_handler(KeyboardInterrupt)), \
-         signal_handler('SIGHUP', raising_signal_handler(SigHup)), \
-         signal_handler('SIGTERM', raising_signal_handler(SigTerm)), \
-         signal_handler('SIGUSR1', sig_info_handler), \
-         signal_handler('SIGUSR2', sig_trace_handler), \
-         signal_handler('SIGINFO', sig_info_handler):
+    with signal_handler("SIGINT", raising_signal_handler(KeyboardInterrupt)), signal_handler(
+        "SIGHUP", raising_signal_handler(SigHup)
+    ), signal_handler("SIGTERM", raising_signal_handler(SigTerm)), signal_handler(
+        "SIGUSR1", sig_info_handler
+    ), signal_handler(
+        "SIGUSR2", sig_trace_handler
+    ), signal_handler(
+        "SIGINFO", sig_info_handler
+    ):
         archiver = Archiver()
         msg = msgid = tb = None
         tb_log_level = logging.ERROR
         try:
-            args = archiver.get_args(sys.argv, os.environ.get('SSH_ORIGINAL_COMMAND'))
+            args = archiver.get_args(sys.argv, os.environ.get("SSH_ORIGINAL_COMMAND"))
         except Error as e:
             msg = e.get_message()
             tb_log_level = logging.ERROR if e.traceback else logging.DEBUG
-            tb = f'{traceback.format_exc()}\n{sysinfo()}'
+            tb = f"{traceback.format_exc()}\n{sysinfo()}"
             # we might not have logging setup yet, so get out quickly
             print(msg, file=sys.stderr)
             if tb_log_level == logging.ERROR:
@@ -5222,56 +6369,56 @@ def main():  # pragma: no cover
             tb = f"{traceback.format_exc()}\n{sysinfo()}"
             exit_code = e.exit_code
         except RemoteRepository.RPCError as e:
-            important = e.exception_class not in ('LockTimeout', ) and e.traceback
+            important = e.exception_class not in ("LockTimeout",) and e.traceback
             msgid = e.exception_class
             tb_log_level = logging.ERROR if important else logging.DEBUG
             if important:
                 msg = e.exception_full
             else:
                 msg = e.get_message()
-            tb = '\n'.join('Borg server: ' + l for l in e.sysinfo.splitlines())
+            tb = "\n".join("Borg server: " + l for l in e.sysinfo.splitlines())
             tb += "\n" + sysinfo()
             exit_code = EXIT_ERROR
         except Exception:
-            msg = 'Local Exception'
-            msgid = 'Exception'
+            msg = "Local Exception"
+            msgid = "Exception"
             tb_log_level = logging.ERROR
-            tb = f'{traceback.format_exc()}\n{sysinfo()}'
+            tb = f"{traceback.format_exc()}\n{sysinfo()}"
             exit_code = EXIT_ERROR
         except KeyboardInterrupt:
-            msg = 'Keyboard interrupt'
+            msg = "Keyboard interrupt"
             tb_log_level = logging.DEBUG
-            tb = f'{traceback.format_exc()}\n{sysinfo()}'
+            tb = f"{traceback.format_exc()}\n{sysinfo()}"
             exit_code = EXIT_SIGNAL_BASE + 2
         except SigTerm:
-            msg = 'Received SIGTERM'
-            msgid = 'Signal.SIGTERM'
+            msg = "Received SIGTERM"
+            msgid = "Signal.SIGTERM"
             tb_log_level = logging.DEBUG
-            tb = f'{traceback.format_exc()}\n{sysinfo()}'
+            tb = f"{traceback.format_exc()}\n{sysinfo()}"
             exit_code = EXIT_SIGNAL_BASE + 15
         except SigHup:
-            msg = 'Received SIGHUP.'
-            msgid = 'Signal.SIGHUP'
+            msg = "Received SIGHUP."
+            msgid = "Signal.SIGHUP"
             exit_code = EXIT_SIGNAL_BASE + 1
         if msg:
             logger.error(msg, msgid=msgid)
         if tb:
             logger.log(tb_log_level, tb)
         if args.show_rc:
-            rc_logger = logging.getLogger('borg.output.show-rc')
-            exit_msg = 'terminating with %s status, rc %d'
+            rc_logger = logging.getLogger("borg.output.show-rc")
+            exit_msg = "terminating with %s status, rc %d"
             if exit_code == EXIT_SUCCESS:
-                rc_logger.info(exit_msg % ('success', exit_code))
+                rc_logger.info(exit_msg % ("success", exit_code))
             elif exit_code == EXIT_WARNING:
-                rc_logger.warning(exit_msg % ('warning', exit_code))
+                rc_logger.warning(exit_msg % ("warning", exit_code))
             elif exit_code == EXIT_ERROR:
-                rc_logger.error(exit_msg % ('error', exit_code))
+                rc_logger.error(exit_msg % ("error", exit_code))
             elif exit_code >= EXIT_SIGNAL_BASE:
-                rc_logger.error(exit_msg % ('signal', exit_code))
+                rc_logger.error(exit_msg % ("signal", exit_code))
             else:
-                rc_logger.error(exit_msg % ('abnormal', exit_code or 666))
+                rc_logger.error(exit_msg % ("abnormal", exit_code or 666))
         sys.exit(exit_code)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     main()
diff --git a/src/borg/cache.py b/src/borg/cache.py
index 5addd34e1..a6148c66d 100644
--- a/src/borg/cache.py
+++ b/src/borg/cache.py
@@ -10,7 +10,7 @@ from .logger import create_logger
 
 logger = create_logger()
 
-files_cache_logger = create_logger('borg.debug.files_cache')
+files_cache_logger = create_logger("borg.debug.files_cache")
 
 from .constants import CACHE_README, FILES_CACHE_MODE_DISABLED
 from .hashindex import ChunkIndex, ChunkIndexEntry, CacheSynchronizer
@@ -37,7 +37,7 @@ from .remote import cache_if_remote
 from .repository import LIST_SCAN_LIMIT
 
 # note: cmtime might me either a ctime or a mtime timestamp
-FileCacheEntry = namedtuple('FileCacheEntry', 'age inode size cmtime chunk_ids')
+FileCacheEntry = namedtuple("FileCacheEntry", "age inode size cmtime chunk_ids")
 
 
 class SecurityManager:
@@ -64,9 +64,9 @@ class SecurityManager:
         self.repository = repository
         self.dir = get_security_dir(repository.id_str)
         self.cache_dir = cache_dir(repository)
-        self.key_type_file = os.path.join(self.dir, 'key-type')
-        self.location_file = os.path.join(self.dir, 'location')
-        self.manifest_ts_file = os.path.join(self.dir, 'manifest-timestamp')
+        self.key_type_file = os.path.join(self.dir, "key-type")
+        self.location_file = os.path.join(self.dir, "location")
+        self.manifest_ts_file = os.path.join(self.dir, "manifest-timestamp")
 
     @staticmethod
     def destroy(repository, path=None):
@@ -76,8 +76,7 @@ class SecurityManager:
             shutil.rmtree(path)
 
     def known(self):
-        return all(os.path.exists(f)
-                   for f in (self.key_type_file, self.location_file, self.manifest_ts_file))
+        return all(os.path.exists(f) for f in (self.key_type_file, self.location_file, self.manifest_ts_file))
 
     def key_matches(self, key):
         if not self.known():
@@ -87,14 +86,14 @@ class SecurityManager:
                 type = fd.read()
                 return type == str(key.TYPE)
         except OSError as exc:
-            logger.warning('Could not read/parse key type file: %s', exc)
+            logger.warning("Could not read/parse key type file: %s", exc)
 
     def save(self, manifest, key):
-        logger.debug('security: saving state for %s to %s', self.repository.id_str, self.dir)
+        logger.debug("security: saving state for %s to %s", self.repository.id_str, self.dir)
         current_location = self.repository._location.canonical_path()
-        logger.debug('security: current location   %s', current_location)
-        logger.debug('security: key type           %s', str(key.TYPE))
-        logger.debug('security: manifest timestamp %s', manifest.timestamp)
+        logger.debug("security: current location   %s", current_location)
+        logger.debug("security: key type           %s", str(key.TYPE))
+        logger.debug("security: manifest timestamp %s", manifest.timestamp)
         with SaveFile(self.location_file) as fd:
             fd.write(current_location)
         with SaveFile(self.key_type_file) as fd:
@@ -107,28 +106,36 @@ class SecurityManager:
         try:
             with open(self.location_file) as fd:
                 previous_location = fd.read()
-            logger.debug('security: read previous location %r', previous_location)
+            logger.debug("security: read previous location %r", previous_location)
         except FileNotFoundError:
-            logger.debug('security: previous location file %s not found', self.location_file)
+            logger.debug("security: previous location file %s not found", self.location_file)
             previous_location = None
         except OSError as exc:
-            logger.warning('Could not read previous location file: %s', exc)
+            logger.warning("Could not read previous location file: %s", exc)
             previous_location = None
         if cache_config and cache_config.previous_location and previous_location != cache_config.previous_location:
             # Reconcile cache and security dir; we take the cache location.
             previous_location = cache_config.previous_location
-            logger.debug('security: using previous_location of cache: %r', previous_location)
+            logger.debug("security: using previous_location of cache: %r", previous_location)
 
         repository_location = self.repository._location.canonical_path()
         if previous_location and previous_location != repository_location:
-            msg = ("Warning: The repository at location {} was previously located at {}\n".format(
-                repository_location, previous_location) +
-                "Do you want to continue? [yN] ")
-            if not yes(msg, false_msg="Aborting.", invalid_msg="Invalid answer, aborting.",
-                       retry=False, env_var_override='BORG_RELOCATED_REPO_ACCESS_IS_OK'):
+            msg = (
+                "Warning: The repository at location {} was previously located at {}\n".format(
+                    repository_location, previous_location
+                )
+                + "Do you want to continue? [yN] "
+            )
+            if not yes(
+                msg,
+                false_msg="Aborting.",
+                invalid_msg="Invalid answer, aborting.",
+                retry=False,
+                env_var_override="BORG_RELOCATED_REPO_ACCESS_IS_OK",
+            ):
                 raise Cache.RepositoryAccessAborted()
             # adapt on-disk config immediately if the new location was accepted
-            logger.debug('security: updating location stored in cache and security dir')
+            logger.debug("security: updating location stored in cache and security dir")
             with SaveFile(self.location_file) as fd:
                 fd.write(repository_location)
             if cache_config:
@@ -138,16 +145,16 @@ class SecurityManager:
         try:
             with open(self.manifest_ts_file) as fd:
                 timestamp = fd.read()
-            logger.debug('security: read manifest timestamp %r', timestamp)
+            logger.debug("security: read manifest timestamp %r", timestamp)
         except FileNotFoundError:
-            logger.debug('security: manifest timestamp file %s not found', self.manifest_ts_file)
-            timestamp = ''
+            logger.debug("security: manifest timestamp file %s not found", self.manifest_ts_file)
+            timestamp = ""
         except OSError as exc:
-            logger.warning('Could not read previous location file: %s', exc)
-            timestamp = ''
+            logger.warning("Could not read previous location file: %s", exc)
+            timestamp = ""
         if cache_config:
-            timestamp = max(timestamp, cache_config.timestamp or '')
-        logger.debug('security: determined newest manifest timestamp as %s', timestamp)
+            timestamp = max(timestamp, cache_config.timestamp or "")
+        logger.debug("security: determined newest manifest timestamp as %s", timestamp)
         # If repository is older than the cache or security dir something fishy is going on
         if timestamp and timestamp > manifest.timestamp:
             if isinstance(key, PlaintextKey):
@@ -175,30 +182,36 @@ class SecurityManager:
                     self._assert_secure(manifest, key, cache_config)
             else:
                 self._assert_secure(manifest, key)
-        logger.debug('security: repository checks ok, allowing access')
+        logger.debug("security: repository checks ok, allowing access")
 
     def _assert_secure(self, manifest, key, cache_config=None):
         self.assert_location_matches(cache_config)
         self.assert_key_type(key, cache_config)
         self.assert_no_manifest_replay(manifest, key, cache_config)
         if not self.known():
-            logger.debug('security: remembering previously unknown repository')
+            logger.debug("security: remembering previously unknown repository")
             self.save(manifest, key)
 
     def assert_access_unknown(self, warn_if_unencrypted, manifest, key):
         # warn_if_unencrypted=False is only used for initializing a new repository.
         # Thus, avoiding asking about a repository that's currently initializing.
         if not key.logically_encrypted and not self.known():
-            msg = ("Warning: Attempting to access a previously unknown unencrypted repository!\n" +
-                   "Do you want to continue? [yN] ")
-            allow_access = not warn_if_unencrypted or yes(msg, false_msg="Aborting.",
+            msg = (
+                "Warning: Attempting to access a previously unknown unencrypted repository!\n"
+                + "Do you want to continue? [yN] "
+            )
+            allow_access = not warn_if_unencrypted or yes(
+                msg,
+                false_msg="Aborting.",
                 invalid_msg="Invalid answer, aborting.",
-                retry=False, env_var_override='BORG_UNKNOWN_UNENCRYPTED_REPO_ACCESS_IS_OK')
+                retry=False,
+                env_var_override="BORG_UNKNOWN_UNENCRYPTED_REPO_ACCESS_IS_OK",
+            )
             if allow_access:
                 if warn_if_unencrypted:
-                    logger.debug('security: remembering unknown unencrypted repository (explicitly allowed)')
+                    logger.debug("security: remembering unknown unencrypted repository (explicitly allowed)")
                 else:
-                    logger.debug('security: initializing unencrypted repository')
+                    logger.debug("security: initializing unencrypted repository")
                 self.save(manifest, key)
             else:
                 raise Cache.CacheInitAbortedError()
@@ -214,10 +227,17 @@ def recanonicalize_relative_location(cache_location, repository):
     repo_location = repository._location.canonical_path()
     rl = Location(repo_location)
     cl = Location(cache_location)
-    if cl.proto == rl.proto and cl.user == rl.user and cl.host == rl.host and cl.port == rl.port \
-            and \
-            cl.path and rl.path and \
-            cl.path.startswith('/~/') and rl.path.startswith('/./') and cl.path[3:] == rl.path[3:]:
+    if (
+        cl.proto == rl.proto
+        and cl.user == rl.user
+        and cl.host == rl.host
+        and cl.port == rl.port
+        and cl.path
+        and rl.path
+        and cl.path.startswith("/~/")
+        and rl.path.startswith("/./")
+        and cl.path[3:] == rl.path[3:]
+    ):
         # everything is same except the expected change in relative path canonicalization,
         # update previous_location to avoid warning / user query about changed location:
         return repo_location
@@ -230,19 +250,19 @@ def cache_dir(repository, path=None):
 
 
 def files_cache_name():
-    suffix = os.environ.get('BORG_FILES_CACHE_SUFFIX', '')
-    return 'files.' + suffix if suffix else 'files'
+    suffix = os.environ.get("BORG_FILES_CACHE_SUFFIX", "")
+    return "files." + suffix if suffix else "files"
 
 
 def discover_files_cache_name(path):
-    return [fn for fn in os.listdir(path) if fn == 'files' or fn.startswith('files.')][0]
+    return [fn for fn in os.listdir(path) if fn == "files" or fn.startswith("files.")][0]
 
 
 class CacheConfig:
     def __init__(self, repository, path=None, lock_wait=None):
         self.repository = repository
         self.path = cache_dir(repository, path)
-        self.config_path = os.path.join(self.path, 'config')
+        self.config_path = os.path.join(self.path, "config")
         self.lock = None
         self.lock_wait = lock_wait
 
@@ -259,17 +279,17 @@ class CacheConfig:
     def create(self):
         assert not self.exists()
         config = configparser.ConfigParser(interpolation=None)
-        config.add_section('cache')
-        config.set('cache', 'version', '1')
-        config.set('cache', 'repository', self.repository.id_str)
-        config.set('cache', 'manifest', '')
-        config.add_section('integrity')
-        config.set('integrity', 'manifest', '')
+        config.add_section("cache")
+        config.set("cache", "version", "1")
+        config.set("cache", "repository", self.repository.id_str)
+        config.set("cache", "manifest", "")
+        config.add_section("integrity")
+        config.set("integrity", "manifest", "")
         with SaveFile(self.config_path) as fd:
             config.write(fd)
 
     def open(self):
-        self.lock = Lock(os.path.join(self.path, 'lock'), exclusive=True, timeout=self.lock_wait).acquire()
+        self.lock = Lock(os.path.join(self.path, "lock"), exclusive=True, timeout=self.lock_wait).acquire()
         self.load()
 
     def load(self):
@@ -277,15 +297,17 @@ class CacheConfig:
         with open(self.config_path) as fd:
             self._config.read_file(fd)
         self._check_upgrade(self.config_path)
-        self.id = self._config.get('cache', 'repository')
-        self.manifest_id = unhexlify(self._config.get('cache', 'manifest'))
-        self.timestamp = self._config.get('cache', 'timestamp', fallback=None)
-        self.key_type = self._config.get('cache', 'key_type', fallback=None)
-        self.ignored_features = set(parse_stringified_list(self._config.get('cache', 'ignored_features', fallback='')))
-        self.mandatory_features = set(parse_stringified_list(self._config.get('cache', 'mandatory_features', fallback='')))
+        self.id = self._config.get("cache", "repository")
+        self.manifest_id = unhexlify(self._config.get("cache", "manifest"))
+        self.timestamp = self._config.get("cache", "timestamp", fallback=None)
+        self.key_type = self._config.get("cache", "key_type", fallback=None)
+        self.ignored_features = set(parse_stringified_list(self._config.get("cache", "ignored_features", fallback="")))
+        self.mandatory_features = set(
+            parse_stringified_list(self._config.get("cache", "mandatory_features", fallback=""))
+        )
         try:
-            self.integrity = dict(self._config.items('integrity'))
-            if self._config.get('cache', 'manifest') != self.integrity.pop('manifest'):
+            self.integrity = dict(self._config.items("integrity"))
+            if self._config.get("cache", "manifest") != self.integrity.pop("manifest"):
                 # The cache config file is updated (parsed with ConfigParser, the state of the ConfigParser
                 # is modified and then written out.), not re-created.
                 # Thus, older versions will leave our [integrity] section alone, making the section's data invalid.
@@ -293,30 +315,30 @@ class CacheConfig:
                 # can discern whether an older version interfered by comparing the manifest IDs of this section
                 # and the main [cache] section.
                 self.integrity = {}
-                logger.warning('Cache integrity data not available: old Borg version modified the cache.')
+                logger.warning("Cache integrity data not available: old Borg version modified the cache.")
         except configparser.NoSectionError:
-            logger.debug('Cache integrity: No integrity data found (files, chunks). Cache is from old version.')
+            logger.debug("Cache integrity: No integrity data found (files, chunks). Cache is from old version.")
             self.integrity = {}
-        previous_location = self._config.get('cache', 'previous_location', fallback=None)
+        previous_location = self._config.get("cache", "previous_location", fallback=None)
         if previous_location:
             self.previous_location = recanonicalize_relative_location(previous_location, self.repository)
         else:
             self.previous_location = None
-        self._config.set('cache', 'previous_location', self.repository._location.canonical_path())
+        self._config.set("cache", "previous_location", self.repository._location.canonical_path())
 
     def save(self, manifest=None, key=None):
         if manifest:
-            self._config.set('cache', 'manifest', manifest.id_str)
-            self._config.set('cache', 'timestamp', manifest.timestamp)
-            self._config.set('cache', 'ignored_features', ','.join(self.ignored_features))
-            self._config.set('cache', 'mandatory_features', ','.join(self.mandatory_features))
-            if not self._config.has_section('integrity'):
-                self._config.add_section('integrity')
+            self._config.set("cache", "manifest", manifest.id_str)
+            self._config.set("cache", "timestamp", manifest.timestamp)
+            self._config.set("cache", "ignored_features", ",".join(self.ignored_features))
+            self._config.set("cache", "mandatory_features", ",".join(self.mandatory_features))
+            if not self._config.has_section("integrity"):
+                self._config.add_section("integrity")
             for file, integrity_data in self.integrity.items():
-                self._config.set('integrity', file, integrity_data)
-            self._config.set('integrity', 'manifest', manifest.id_str)
+                self._config.set("integrity", file, integrity_data)
+            self._config.set("integrity", "manifest", manifest.id_str)
         if key:
-            self._config.set('cache', 'key_type', str(key.TYPE))
+            self._config.set("cache", "key_type", str(key.TYPE))
         with SaveFile(self.config_path) as fd:
             self._config.write(fd)
 
@@ -327,20 +349,21 @@ class CacheConfig:
 
     def _check_upgrade(self, config_path):
         try:
-            cache_version = self._config.getint('cache', 'version')
+            cache_version = self._config.getint("cache", "version")
             wanted_version = 1
             if cache_version != wanted_version:
                 self.close()
-                raise Exception('%s has unexpected cache version %d (wanted: %d).' %
-                                (config_path, cache_version, wanted_version))
+                raise Exception(
+                    "%s has unexpected cache version %d (wanted: %d)." % (config_path, cache_version, wanted_version)
+                )
         except configparser.NoSectionError:
             self.close()
-            raise Exception('%s does not look like a Borg cache.' % config_path) from None
+            raise Exception("%s does not look like a Borg cache." % config_path) from None
 
 
 class Cache:
-    """Client Side cache
-    """
+    """Client Side cache"""
+
     class RepositoryIDNotUnique(Error):
         """Cache is newer than repository - do you have multiple, independently updated repos with same ID?"""
 
@@ -359,29 +382,56 @@ class Cache:
     @staticmethod
     def break_lock(repository, path=None):
         path = cache_dir(repository, path)
-        Lock(os.path.join(path, 'lock'), exclusive=True).break_lock()
+        Lock(os.path.join(path, "lock"), exclusive=True).break_lock()
 
     @staticmethod
     def destroy(repository, path=None):
         """destroy the cache for ``repository`` or at ``path``"""
         path = path or os.path.join(get_cache_dir(), repository.id_str)
-        config = os.path.join(path, 'config')
+        config = os.path.join(path, "config")
         if os.path.exists(config):
             os.remove(config)  # kill config first
             shutil.rmtree(path)
 
-    def __new__(cls, repository, key, manifest, path=None, sync=True, warn_if_unencrypted=True,
-                progress=False, lock_wait=None, permit_adhoc_cache=False, cache_mode=FILES_CACHE_MODE_DISABLED,
-                consider_part_files=False, iec=False):
-
+    def __new__(
+        cls,
+        repository,
+        key,
+        manifest,
+        path=None,
+        sync=True,
+        warn_if_unencrypted=True,
+        progress=False,
+        lock_wait=None,
+        permit_adhoc_cache=False,
+        cache_mode=FILES_CACHE_MODE_DISABLED,
+        consider_part_files=False,
+        iec=False,
+    ):
         def local():
-            return LocalCache(repository=repository, key=key, manifest=manifest, path=path, sync=sync,
-                              warn_if_unencrypted=warn_if_unencrypted, progress=progress, iec=iec,
-                              lock_wait=lock_wait, cache_mode=cache_mode, consider_part_files=consider_part_files)
+            return LocalCache(
+                repository=repository,
+                key=key,
+                manifest=manifest,
+                path=path,
+                sync=sync,
+                warn_if_unencrypted=warn_if_unencrypted,
+                progress=progress,
+                iec=iec,
+                lock_wait=lock_wait,
+                cache_mode=cache_mode,
+                consider_part_files=consider_part_files,
+            )
 
         def adhoc():
-            return AdHocCache(repository=repository, key=key, manifest=manifest, lock_wait=lock_wait, iec=iec,
-                              consider_part_files=consider_part_files)
+            return AdHocCache(
+                repository=repository,
+                key=key,
+                manifest=manifest,
+                lock_wait=lock_wait,
+                iec=iec,
+                consider_part_files=consider_part_files,
+            )
 
         if not permit_adhoc_cache:
             return local()
@@ -397,9 +447,9 @@ class Cache:
             # Don't nest cache locks
             if cache_in_sync:
                 # Local cache is in sync, use it
-                logger.debug('Cache: choosing local cache (in sync)')
+                logger.debug("Cache: choosing local cache (in sync)")
                 return local()
-        logger.debug('Cache: choosing ad-hoc cache (local cache does not exist or is not in sync)')
+        logger.debug("Cache: choosing ad-hoc cache (local cache does not exist or is not in sync)")
         return adhoc()
 
 
@@ -417,10 +467,11 @@ Total chunks: {0.total_chunks}
     def __str__(self):
         return self.str_format.format(self.format_tuple())
 
-    Summary = namedtuple('Summary', ['total_size', 'unique_size', 'total_unique_chunks', 'total_chunks'])
+    Summary = namedtuple("Summary", ["total_size", "unique_size", "total_unique_chunks", "total_chunks"])
 
     def stats(self):
         from .archive import Archive
+
         # XXX: this should really be moved down to `hashindex.pyx`
         total_size, unique_size, total_unique_chunks, total_chunks = self.chunks.summarize()
         # the above values have the problem that they do not consider part files,
@@ -430,8 +481,9 @@ Total chunks: {0.total_chunks}
         # so we can just sum up all archives to get the "all archives" stats:
         total_size = 0
         for archive_name in self.manifest.archives:
-            archive = Archive(self.repository, self.key, self.manifest, archive_name,
-                              consider_part_files=self.consider_part_files)
+            archive = Archive(
+                self.repository, self.key, self.manifest, archive_name, consider_part_files=self.consider_part_files
+            )
             stats = archive.calc_stats(self, want_unique=False)
             total_size += stats.osize
         stats = self.Summary(total_size, unique_size, total_unique_chunks, total_chunks)._asdict()
@@ -439,7 +491,7 @@ Total chunks: {0.total_chunks}
 
     def format_tuple(self):
         stats = self.stats()
-        for field in ['total_size', 'unique_size']:
+        for field in ["total_size", "unique_size"]:
             stats[field] = format_file_size(stats[field], iec=self.iec)
         return self.Summary(**stats)
 
@@ -449,9 +501,20 @@ class LocalCache(CacheStatsMixin):
     Persistent, local (client-side) cache.
     """
 
-    def __init__(self, repository, key, manifest, path=None, sync=True, warn_if_unencrypted=True,
-                 progress=False, lock_wait=None, cache_mode=FILES_CACHE_MODE_DISABLED, consider_part_files=False,
-                 iec=False):
+    def __init__(
+        self,
+        repository,
+        key,
+        manifest,
+        path=None,
+        sync=True,
+        warn_if_unencrypted=True,
+        progress=False,
+        lock_wait=None,
+        cache_mode=FILES_CACHE_MODE_DISABLED,
+        consider_part_files=False,
+        iec=False,
+    ):
         """
         :param warn_if_unencrypted: print warning if accessing unknown unencrypted repository
         :param lock_wait: timeout for lock acquisition (int [s] or None [wait forever])
@@ -500,30 +563,32 @@ class LocalCache(CacheStatsMixin):
         self.close()
 
     def create(self):
-        """Create a new empty cache at `self.path`
-        """
+        """Create a new empty cache at `self.path`"""
         os.makedirs(self.path)
-        with open(os.path.join(self.path, 'README'), 'w') as fd:
+        with open(os.path.join(self.path, "README"), "w") as fd:
             fd.write(CACHE_README)
         self.cache_config.create()
-        ChunkIndex().write(os.path.join(self.path, 'chunks'))
-        os.makedirs(os.path.join(self.path, 'chunks.archive.d'))
+        ChunkIndex().write(os.path.join(self.path, "chunks"))
+        os.makedirs(os.path.join(self.path, "chunks.archive.d"))
         with SaveFile(os.path.join(self.path, files_cache_name()), binary=True):
             pass  # empty file
 
     def _do_open(self):
         self.cache_config.load()
-        with IntegrityCheckedFile(path=os.path.join(self.path, 'chunks'), write=False,
-                                  integrity_data=self.cache_config.integrity.get('chunks')) as fd:
+        with IntegrityCheckedFile(
+            path=os.path.join(self.path, "chunks"),
+            write=False,
+            integrity_data=self.cache_config.integrity.get("chunks"),
+        ) as fd:
             self.chunks = ChunkIndex.read(fd)
-        if 'd' in self.cache_mode:  # d(isabled)
+        if "d" in self.cache_mode:  # d(isabled)
             self.files = None
         else:
             self._read_files()
 
     def open(self):
         if not os.path.isdir(self.path):
-            raise Exception('%s Does not look like a Borg cache' % self.path)
+            raise Exception("%s Does not look like a Borg cache" % self.path)
         self.cache_config.open()
         self.rollback()
 
@@ -535,12 +600,15 @@ class LocalCache(CacheStatsMixin):
     def _read_files(self):
         self.files = {}
         self._newest_cmtime = None
-        logger.debug('Reading files cache ...')
+        logger.debug("Reading files cache ...")
         files_cache_logger.debug("FILES-CACHE-LOAD: starting...")
         msg = None
         try:
-            with IntegrityCheckedFile(path=os.path.join(self.path, files_cache_name()), write=False,
-                                      integrity_data=self.cache_config.integrity.get(files_cache_name())) as fd:
+            with IntegrityCheckedFile(
+                path=os.path.join(self.path, files_cache_name()),
+                write=False,
+                integrity_data=self.cache_config.integrity.get(files_cache_name()),
+            ) as fd:
                 u = msgpack.Unpacker(use_list=True)
                 while True:
                     data = fd.read(64 * 1024)
@@ -561,43 +629,41 @@ class LocalCache(CacheStatsMixin):
             msg = "The files cache is corrupted. [%s]" % str(fie)
         if msg is not None:
             logger.warning(msg)
-            logger.warning('Continuing without files cache - expect lower performance.')
+            logger.warning("Continuing without files cache - expect lower performance.")
             self.files = {}
         files_cache_logger.debug("FILES-CACHE-LOAD: finished, %d entries loaded.", len(self.files))
 
     def begin_txn(self):
         # Initialize transaction snapshot
-        pi = ProgressIndicatorMessage(msgid='cache.begin_transaction')
-        txn_dir = os.path.join(self.path, 'txn.tmp')
+        pi = ProgressIndicatorMessage(msgid="cache.begin_transaction")
+        txn_dir = os.path.join(self.path, "txn.tmp")
         os.mkdir(txn_dir)
-        pi.output('Initializing cache transaction: Reading config')
-        shutil.copy(os.path.join(self.path, 'config'), txn_dir)
-        pi.output('Initializing cache transaction: Reading chunks')
-        shutil.copy(os.path.join(self.path, 'chunks'), txn_dir)
-        pi.output('Initializing cache transaction: Reading files')
+        pi.output("Initializing cache transaction: Reading config")
+        shutil.copy(os.path.join(self.path, "config"), txn_dir)
+        pi.output("Initializing cache transaction: Reading chunks")
+        shutil.copy(os.path.join(self.path, "chunks"), txn_dir)
+        pi.output("Initializing cache transaction: Reading files")
         try:
             shutil.copy(os.path.join(self.path, files_cache_name()), txn_dir)
         except FileNotFoundError:
             with SaveFile(os.path.join(txn_dir, files_cache_name()), binary=True):
                 pass  # empty file
-        os.rename(os.path.join(self.path, 'txn.tmp'),
-                  os.path.join(self.path, 'txn.active'))
+        os.rename(os.path.join(self.path, "txn.tmp"), os.path.join(self.path, "txn.active"))
         self.txn_active = True
         pi.finish()
 
     def commit(self):
-        """Commit transaction
-        """
+        """Commit transaction"""
         if not self.txn_active:
             return
         self.security_manager.save(self.manifest, self.key)
-        pi = ProgressIndicatorMessage(msgid='cache.commit')
+        pi = ProgressIndicatorMessage(msgid="cache.commit")
         if self.files is not None:
             if self._newest_cmtime is None:
                 # was never set because no files were modified/added
-                self._newest_cmtime = 2 ** 63 - 1  # nanoseconds, good until y2262
-            ttl = int(os.environ.get('BORG_FILES_CACHE_TTL', 20))
-            pi.output('Saving files cache')
+                self._newest_cmtime = 2**63 - 1  # nanoseconds, good until y2262
+            ttl = int(os.environ.get("BORG_FILES_CACHE_TTL", 20))
+            pi.output("Saving files cache")
             files_cache_logger.debug("FILES-CACHE-SAVE: starting...")
             with IntegrityCheckedFile(path=os.path.join(self.path, files_cache_name()), write=True) as fd:
                 entry_count = 0
@@ -606,41 +672,45 @@ class LocalCache(CacheStatsMixin):
                     # this is to avoid issues with filesystem snapshots and cmtime granularity.
                     # Also keep files from older backups that have not reached BORG_FILES_CACHE_TTL yet.
                     entry = FileCacheEntry(*msgpack.unpackb(item))
-                    if entry.age == 0 and timestamp_to_int(entry.cmtime) < self._newest_cmtime or \
-                       entry.age > 0 and entry.age < ttl:
+                    if (
+                        entry.age == 0
+                        and timestamp_to_int(entry.cmtime) < self._newest_cmtime
+                        or entry.age > 0
+                        and entry.age < ttl
+                    ):
                         msgpack.pack((path_hash, entry), fd)
                         entry_count += 1
             files_cache_logger.debug("FILES-CACHE-KILL: removed all old entries with age >= TTL [%d]", ttl)
-            files_cache_logger.debug("FILES-CACHE-KILL: removed all current entries with newest cmtime %d", self._newest_cmtime)
+            files_cache_logger.debug(
+                "FILES-CACHE-KILL: removed all current entries with newest cmtime %d", self._newest_cmtime
+            )
             files_cache_logger.debug("FILES-CACHE-SAVE: finished, %d remaining entries saved.", entry_count)
             self.cache_config.integrity[files_cache_name()] = fd.integrity_data
-        pi.output('Saving chunks cache')
-        with IntegrityCheckedFile(path=os.path.join(self.path, 'chunks'), write=True) as fd:
+        pi.output("Saving chunks cache")
+        with IntegrityCheckedFile(path=os.path.join(self.path, "chunks"), write=True) as fd:
             self.chunks.write(fd)
-        self.cache_config.integrity['chunks'] = fd.integrity_data
-        pi.output('Saving cache config')
+        self.cache_config.integrity["chunks"] = fd.integrity_data
+        pi.output("Saving cache config")
         self.cache_config.save(self.manifest, self.key)
-        os.rename(os.path.join(self.path, 'txn.active'),
-                  os.path.join(self.path, 'txn.tmp'))
-        shutil.rmtree(os.path.join(self.path, 'txn.tmp'))
+        os.rename(os.path.join(self.path, "txn.active"), os.path.join(self.path, "txn.tmp"))
+        shutil.rmtree(os.path.join(self.path, "txn.tmp"))
         self.txn_active = False
         pi.finish()
 
     def rollback(self):
-        """Roll back partial and aborted transactions
-        """
+        """Roll back partial and aborted transactions"""
         # Remove partial transaction
-        if os.path.exists(os.path.join(self.path, 'txn.tmp')):
-            shutil.rmtree(os.path.join(self.path, 'txn.tmp'))
+        if os.path.exists(os.path.join(self.path, "txn.tmp")):
+            shutil.rmtree(os.path.join(self.path, "txn.tmp"))
         # Roll back active transaction
-        txn_dir = os.path.join(self.path, 'txn.active')
+        txn_dir = os.path.join(self.path, "txn.active")
         if os.path.exists(txn_dir):
-            shutil.copy(os.path.join(txn_dir, 'config'), self.path)
-            shutil.copy(os.path.join(txn_dir, 'chunks'), self.path)
+            shutil.copy(os.path.join(txn_dir, "config"), self.path)
+            shutil.copy(os.path.join(txn_dir, "chunks"), self.path)
             shutil.copy(os.path.join(txn_dir, discover_files_cache_name(txn_dir)), self.path)
-            os.rename(txn_dir, os.path.join(self.path, 'txn.tmp'))
-            if os.path.exists(os.path.join(self.path, 'txn.tmp')):
-                shutil.rmtree(os.path.join(self.path, 'txn.tmp'))
+            os.rename(txn_dir, os.path.join(self.path, "txn.tmp"))
+            if os.path.exists(os.path.join(self.path, "txn.tmp")):
+                shutil.rmtree(os.path.join(self.path, "txn.tmp"))
         self.txn_active = False
         self._do_open()
 
@@ -654,13 +724,13 @@ class LocalCache(CacheStatsMixin):
         get removed and a new master chunks index is built by merging all
         archive indexes.
         """
-        archive_path = os.path.join(self.path, 'chunks.archive.d')
+        archive_path = os.path.join(self.path, "chunks.archive.d")
         # Instrumentation
         processed_item_metadata_bytes = 0
         processed_item_metadata_chunks = 0
         compact_chunks_archive_saved_space = 0
 
-        def mkpath(id, suffix=''):
+        def mkpath(id, suffix=""):
             id_hex = bin_to_hex(id)
             path = os.path.join(archive_path, id_hex + suffix)
             return path
@@ -670,8 +740,9 @@ class LocalCache(CacheStatsMixin):
                 fns = os.listdir(archive_path)
                 # filenames with 64 hex digits == 256bit,
                 # or compact indices which are 64 hex digits + ".compact"
-                return {unhexlify(fn) for fn in fns if len(fn) == 64} | \
-                       {unhexlify(fn[:64]) for fn in fns if len(fn) == 72 and fn.endswith('.compact')}
+                return {unhexlify(fn) for fn in fns if len(fn) == 64} | {
+                    unhexlify(fn[:64]) for fn in fns if len(fn) == 72 and fn.endswith(".compact")
+                }
             else:
                 return set()
 
@@ -685,14 +756,14 @@ class LocalCache(CacheStatsMixin):
         def cleanup_cached_archive(id, cleanup_compact=True):
             try:
                 os.unlink(mkpath(id))
-                os.unlink(mkpath(id) + '.integrity')
+                os.unlink(mkpath(id) + ".integrity")
             except FileNotFoundError:
                 pass
             if not cleanup_compact:
                 return
             try:
-                os.unlink(mkpath(id, suffix='.compact'))
-                os.unlink(mkpath(id, suffix='.compact') + '.integrity')
+                os.unlink(mkpath(id, suffix=".compact"))
+                os.unlink(mkpath(id, suffix=".compact") + ".integrity")
             except FileNotFoundError:
                 pass
 
@@ -703,7 +774,7 @@ class LocalCache(CacheStatsMixin):
             chunk_idx.add(archive_id, 1, len(data))
             archive = ArchiveItem(internal_dict=msgpack.unpackb(data))
             if archive.version not in (1, 2):  # legacy
-                raise Exception('Unknown archive metadata version')
+                raise Exception("Unknown archive metadata version")
             sync = CacheSynchronizer(chunk_idx)
             for item_id, (csize, data) in zip(archive.items, decrypted_repository.get_many(archive.items)):
                 chunk_idx.add(item_id, 1, len(data))
@@ -716,11 +787,12 @@ class LocalCache(CacheStatsMixin):
         def write_archive_index(archive_id, chunk_idx):
             nonlocal compact_chunks_archive_saved_space
             compact_chunks_archive_saved_space += chunk_idx.compact()
-            fn = mkpath(archive_id, suffix='.compact')
-            fn_tmp = mkpath(archive_id, suffix='.tmp')
+            fn = mkpath(archive_id, suffix=".compact")
+            fn_tmp = mkpath(archive_id, suffix=".tmp")
             try:
-                with DetachedIntegrityCheckedFile(path=fn_tmp, write=True,
-                                                  filename=bin_to_hex(archive_id) + '.compact') as fd:
+                with DetachedIntegrityCheckedFile(
+                    path=fn_tmp, write=True, filename=bin_to_hex(archive_id) + ".compact"
+                ) as fd:
                     chunk_idx.write(fd)
             except Exception:
                 safe_unlink(fn_tmp)
@@ -733,7 +805,7 @@ class LocalCache(CacheStatsMixin):
             try:
                 try:
                     # Attempt to load compact index first
-                    with DetachedIntegrityCheckedFile(path=archive_chunk_idx_path + '.compact', write=False) as fd:
+                    with DetachedIntegrityCheckedFile(path=archive_chunk_idx_path + ".compact", write=False) as fd:
                         archive_chunk_idx = ChunkIndex.read(fd, permit_compact=True)
                     # In case a non-compact index exists, delete it.
                     cleanup_cached_archive(archive_id, cleanup_compact=False)
@@ -744,14 +816,14 @@ class LocalCache(CacheStatsMixin):
                     with DetachedIntegrityCheckedFile(path=archive_chunk_idx_path, write=False) as fd:
                         archive_chunk_idx = ChunkIndex.read(fd)
             except FileIntegrityError as fie:
-                logger.error('Cached archive chunk index of %s is corrupted: %s', archive_name, fie)
+                logger.error("Cached archive chunk index of %s is corrupted: %s", archive_name, fie)
                 # Delete corrupted index, set warning. A new index must be build.
                 cleanup_cached_archive(archive_id)
                 set_ec(EXIT_WARNING)
                 return None
 
             # Convert to compact index. Delete the existing index first.
-            logger.debug('Found non-compact index for %s, converting to compact.', archive_name)
+            logger.debug("Found non-compact index for %s, converting to compact.", archive_name)
             cleanup_cached_archive(archive_id)
             write_archive_index(archive_id, archive_chunk_idx)
             return archive_chunk_idx
@@ -769,12 +841,16 @@ class LocalCache(CacheStatsMixin):
             return archive_names
 
         def create_master_idx(chunk_idx):
-            logger.info('Synchronizing chunks cache...')
+            logger.info("Synchronizing chunks cache...")
             cached_ids = cached_archives()
             archive_ids = repo_archives()
-            logger.info('Archives: %d, w/ cached Idx: %d, w/ outdated Idx: %d, w/o cached Idx: %d.',
-                len(archive_ids), len(cached_ids),
-                len(cached_ids - archive_ids), len(archive_ids - cached_ids))
+            logger.info(
+                "Archives: %d, w/ cached Idx: %d, w/ outdated Idx: %d, w/o cached Idx: %d.",
+                len(archive_ids),
+                len(cached_ids),
+                len(cached_ids - archive_ids),
+                len(archive_ids - cached_ids),
+            )
             # deallocates old hashindex, creates empty hashindex:
             chunk_idx.clear()
             cleanup_outdated(cached_ids - archive_ids)
@@ -783,9 +859,12 @@ class LocalCache(CacheStatsMixin):
             master_index_capacity = len(self.repository)
             if archive_ids:
                 chunk_idx = None if not self.do_cache else ChunkIndex(usable=master_index_capacity)
-                pi = ProgressIndicatorPercent(total=len(archive_ids), step=0.1,
-                                              msg='%3.0f%% Syncing chunks cache. Processing archive %s',
-                                              msgid='cache.sync')
+                pi = ProgressIndicatorPercent(
+                    total=len(archive_ids),
+                    step=0.1,
+                    msg="%3.0f%% Syncing chunks cache. Processing archive %s",
+                    msgid="cache.sync",
+                )
                 archive_ids_to_names = get_archive_ids_to_names(archive_ids)
                 for archive_id, archive_name in archive_ids_to_names.items():
                     pi.show(info=[remove_surrogates(archive_name)])
@@ -797,31 +876,36 @@ class LocalCache(CacheStatsMixin):
                         if archive_id not in cached_ids:
                             # Do not make this an else branch; the FileIntegrityError exception handler
                             # above can remove *archive_id* from *cached_ids*.
-                            logger.info('Fetching and building archive index for %s ...', archive_name)
+                            logger.info("Fetching and building archive index for %s ...", archive_name)
                             archive_chunk_idx = ChunkIndex()
                             fetch_and_build_idx(archive_id, decrypted_repository, archive_chunk_idx)
                         logger.info("Merging into master chunks index ...")
                         chunk_idx.merge(archive_chunk_idx)
                     else:
                         chunk_idx = chunk_idx or ChunkIndex(usable=master_index_capacity)
-                        logger.info('Fetching archive index for %s ...', archive_name)
+                        logger.info("Fetching archive index for %s ...", archive_name)
                         fetch_and_build_idx(archive_id, decrypted_repository, chunk_idx)
                 pi.finish()
-                logger.debug('Cache sync: processed %s (%d chunks) of metadata',
-                             format_file_size(processed_item_metadata_bytes), processed_item_metadata_chunks)
-                logger.debug('Cache sync: compact chunks.archive.d storage saved %s bytes',
-                             format_file_size(compact_chunks_archive_saved_space))
-            logger.info('Done.')
+                logger.debug(
+                    "Cache sync: processed %s (%d chunks) of metadata",
+                    format_file_size(processed_item_metadata_bytes),
+                    processed_item_metadata_chunks,
+                )
+                logger.debug(
+                    "Cache sync: compact chunks.archive.d storage saved %s bytes",
+                    format_file_size(compact_chunks_archive_saved_space),
+                )
+            logger.info("Done.")
             return chunk_idx
 
         def legacy_cleanup():
             """bring old cache dirs into the desired state (cleanup and adapt)"""
             try:
-                os.unlink(os.path.join(self.path, 'chunks.archive'))
+                os.unlink(os.path.join(self.path, "chunks.archive"))
             except:
                 pass
             try:
-                os.unlink(os.path.join(self.path, 'chunks.archive.tmp'))
+                os.unlink(os.path.join(self.path, "chunks.archive.tmp"))
             except:
                 pass
             try:
@@ -832,7 +916,7 @@ class LocalCache(CacheStatsMixin):
         # The cache can be used by a command that e.g. only checks against Manifest.Operation.WRITE,
         # which does not have to include all flags from Manifest.Operation.READ.
         # Since the sync will attempt to read archives, check compatibility with Manifest.Operation.READ.
-        self.manifest.check_repository_compatibility((Manifest.Operation.READ, ))
+        self.manifest.check_repository_compatibility((Manifest.Operation.READ,))
 
         self.begin_txn()
         with cache_if_remote(self.repository, decrypted_cache=self.key) as decrypted_repository:
@@ -856,15 +940,15 @@ class LocalCache(CacheStatsMixin):
 
     def wipe_cache(self):
         logger.warning("Discarding incompatible cache and forcing a cache rebuild")
-        archive_path = os.path.join(self.path, 'chunks.archive.d')
+        archive_path = os.path.join(self.path, "chunks.archive.d")
         if os.path.isdir(archive_path):
-            shutil.rmtree(os.path.join(self.path, 'chunks.archive.d'))
-            os.makedirs(os.path.join(self.path, 'chunks.archive.d'))
+            shutil.rmtree(os.path.join(self.path, "chunks.archive.d"))
+            os.makedirs(os.path.join(self.path, "chunks.archive.d"))
         self.chunks = ChunkIndex()
         with SaveFile(os.path.join(self.path, files_cache_name()), binary=True):
             pass  # empty file
-        self.cache_config.manifest_id = ''
-        self.cache_config._config.set('cache', 'manifest', '')
+        self.cache_config.manifest_id = ""
+        self.cache_config._config.set("cache", "manifest", "")
 
         self.cache_config.ignored_features = set()
         self.cache_config.mandatory_features = set()
@@ -900,8 +984,9 @@ class LocalCache(CacheStatsMixin):
         if size is not None and stored_size is not None and size != stored_size:
             # we already have a chunk with that id, but different size.
             # this is either a hash collision (unlikely) or corruption or a bug.
-            raise Exception("chunk has same id [%r], but different size (stored: %d new: %d)!" % (
-                            id, stored_size, size))
+            raise Exception(
+                "chunk has same id [%r], but different size (stored: %d new: %d)!" % (id, stored_size, size)
+            )
         return refcount
 
     def chunk_incref(self, id, stats, size=None, part=False):
@@ -936,32 +1021,32 @@ class LocalCache(CacheStatsMixin):
         if not stat.S_ISREG(st.st_mode):
             return False, None
         cache_mode = self.cache_mode
-        if 'd' in cache_mode:  # d(isabled)
-            files_cache_logger.debug('UNKNOWN: files cache disabled')
+        if "d" in cache_mode:  # d(isabled)
+            files_cache_logger.debug("UNKNOWN: files cache disabled")
             return False, None
         # note: r(echunk) does not need the files cache in this method, but the files cache will
         # be updated and saved to disk to memorize the files. To preserve previous generations in
         # the cache, this means that it also needs to get loaded from disk first.
-        if 'r' in cache_mode:  # r(echunk)
-            files_cache_logger.debug('UNKNOWN: rechunking enforced')
+        if "r" in cache_mode:  # r(echunk)
+            files_cache_logger.debug("UNKNOWN: rechunking enforced")
             return False, None
         entry = self.files.get(path_hash)
         if not entry:
-            files_cache_logger.debug('UNKNOWN: no file metadata in cache for: %r', hashed_path)
+            files_cache_logger.debug("UNKNOWN: no file metadata in cache for: %r", hashed_path)
             return False, None
         # we know the file!
         entry = FileCacheEntry(*msgpack.unpackb(entry))
-        if 's' in cache_mode and entry.size != st.st_size:
-            files_cache_logger.debug('KNOWN-CHANGED: file size has changed: %r', hashed_path)
+        if "s" in cache_mode and entry.size != st.st_size:
+            files_cache_logger.debug("KNOWN-CHANGED: file size has changed: %r", hashed_path)
             return True, None
-        if 'i' in cache_mode and entry.inode != st.st_ino:
-            files_cache_logger.debug('KNOWN-CHANGED: file inode number has changed: %r', hashed_path)
+        if "i" in cache_mode and entry.inode != st.st_ino:
+            files_cache_logger.debug("KNOWN-CHANGED: file inode number has changed: %r", hashed_path)
             return True, None
-        if 'c' in cache_mode and timestamp_to_int(entry.cmtime) != st.st_ctime_ns:
-            files_cache_logger.debug('KNOWN-CHANGED: file ctime has changed: %r', hashed_path)
+        if "c" in cache_mode and timestamp_to_int(entry.cmtime) != st.st_ctime_ns:
+            files_cache_logger.debug("KNOWN-CHANGED: file ctime has changed: %r", hashed_path)
             return True, None
-        elif 'm' in cache_mode and timestamp_to_int(entry.cmtime) != st.st_mtime_ns:
-            files_cache_logger.debug('KNOWN-CHANGED: file mtime has changed: %r', hashed_path)
+        elif "m" in cache_mode and timestamp_to_int(entry.cmtime) != st.st_mtime_ns:
+            files_cache_logger.debug("KNOWN-CHANGED: file mtime has changed: %r", hashed_path)
             return True, None
         # we ignored the inode number in the comparison above or it is still same.
         # if it is still the same, replacing it in the tuple doesn't change it.
@@ -979,21 +1064,26 @@ class LocalCache(CacheStatsMixin):
             return
         cache_mode = self.cache_mode
         # note: r(echunk) modes will update the files cache, d(isabled) mode won't
-        if 'd' in cache_mode:
-            files_cache_logger.debug('FILES-CACHE-NOUPDATE: files cache disabled')
+        if "d" in cache_mode:
+            files_cache_logger.debug("FILES-CACHE-NOUPDATE: files cache disabled")
             return
-        if 'c' in cache_mode:
-            cmtime_type = 'ctime'
+        if "c" in cache_mode:
+            cmtime_type = "ctime"
             cmtime_ns = safe_ns(st.st_ctime_ns)
-        elif 'm' in cache_mode:
-            cmtime_type = 'mtime'
+        elif "m" in cache_mode:
+            cmtime_type = "mtime"
             cmtime_ns = safe_ns(st.st_mtime_ns)
-        entry = FileCacheEntry(age=0, inode=st.st_ino, size=st.st_size, cmtime=int_to_timestamp(cmtime_ns), chunk_ids=ids)
+        entry = FileCacheEntry(
+            age=0, inode=st.st_ino, size=st.st_size, cmtime=int_to_timestamp(cmtime_ns), chunk_ids=ids
+        )
         self.files[path_hash] = msgpack.packb(entry)
         self._newest_cmtime = max(self._newest_cmtime or 0, cmtime_ns)
-        files_cache_logger.debug('FILES-CACHE-UPDATE: put %r [has %s] <- %r',
-                                 entry._replace(chunk_ids='[%d entries]' % len(entry.chunk_ids)),
-                                 cmtime_type, hashed_path)
+        files_cache_logger.debug(
+            "FILES-CACHE-UPDATE: put %r [has %s] <- %r",
+            entry._replace(chunk_ids="[%d entries]" % len(entry.chunk_ids)),
+            cmtime_type,
+            hashed_path,
+        )
 
 
 class AdHocCache(CacheStatsMixin):
@@ -1012,8 +1102,9 @@ All archives:                unknown              unknown              unknown
                        Unique chunks         Total chunks
 Chunk index:    {0.total_unique_chunks:20d}             unknown"""
 
-    def __init__(self, repository, key, manifest, warn_if_unencrypted=True, lock_wait=None, consider_part_files=False,
-                 iec=False):
+    def __init__(
+        self, repository, key, manifest, warn_if_unencrypted=True, lock_wait=None, consider_part_files=False, iec=False
+    ):
         CacheStatsMixin.__init__(self, iec=iec)
         self.repository = repository
         self.key = key
@@ -1024,7 +1115,7 @@ Chunk index:    {0.total_unique_chunks:20d}             unknown"""
         self.security_manager = SecurityManager(repository)
         self.security_manager.assert_secure(manifest, key, lock_wait=lock_wait)
 
-        logger.warning('Note: --no-cache-sync is an experimental feature.')
+        logger.warning("Note: --no-cache-sync is an experimental feature.")
 
     # Public API
 
@@ -1035,7 +1126,7 @@ Chunk index:    {0.total_unique_chunks:20d}             unknown"""
         pass
 
     files = None
-    cache_mode = 'd'
+    cache_mode = "d"
 
     def file_known_and_unchanged(self, hashed_path, path_hash, st):
         files_cache_logger.debug("UNKNOWN: files cache not implemented")
@@ -1045,7 +1136,7 @@ Chunk index:    {0.total_unique_chunks:20d}             unknown"""
         pass
 
     def add_chunk(self, id, chunk, stats, *, overwrite=False, wait=True, compress=True, size=None):
-        assert not overwrite, 'AdHocCache does not permit overwrites — trying to use it for recreate?'
+        assert not overwrite, "AdHocCache does not permit overwrites — trying to use it for recreate?"
         if not self._txn_active:
             self.begin_txn()
         if size is None and compress:
@@ -1111,8 +1202,9 @@ Chunk index:    {0.total_unique_chunks:20d}             unknown"""
         # Since we're creating an archive, add 10 % from the start.
         num_chunks = len(self.repository)
         self.chunks = ChunkIndex(usable=num_chunks * 1.1)
-        pi = ProgressIndicatorPercent(total=num_chunks, msg='Downloading chunk list... %3.0f%%',
-                                      msgid='cache.download_chunks')
+        pi = ProgressIndicatorPercent(
+            total=num_chunks, msg="Downloading chunk list... %3.0f%%", msgid="cache.download_chunks"
+        )
         t0 = perf_counter()
         num_requests = 0
         marker = None
@@ -1134,7 +1226,12 @@ Chunk index:    {0.total_unique_chunks:20d}             unknown"""
         del self.chunks[self.manifest.MANIFEST_ID]
         duration = perf_counter() - t0 or 0.01
         pi.finish()
-        logger.debug('AdHocCache: downloaded %d chunk IDs in %.2f s (%d requests), ~%s/s',
-                     num_chunks, duration, num_requests, format_file_size(num_chunks * 34 / duration))
+        logger.debug(
+            "AdHocCache: downloaded %d chunk IDs in %.2f s (%d requests), ~%s/s",
+            num_chunks,
+            duration,
+            num_requests,
+            format_file_size(num_chunks * 34 / duration),
+        )
         # Chunk IDs in a list are encoded in 34 bytes: 1 byte msgpack header, 1 byte length, 32 ID bytes.
         # Protocol overhead is neglected in this calculation.
diff --git a/src/borg/constants.py b/src/borg/constants.py
index ff7840299..a7406a63f 100644
--- a/src/borg/constants.py
+++ b/src/borg/constants.py
@@ -7,7 +7,7 @@ ITEM_KEYS = frozenset(['path', 'source', 'rdev', 'chunks', 'chunks_healthy', 'ha
 # fmt: on
 
 # this is the set of keys that are always present in items:
-REQUIRED_ITEM_KEYS = frozenset(['path', 'mtime', ])
+REQUIRED_ITEM_KEYS = frozenset(["path", "mtime"])
 
 # this set must be kept complete, otherwise rebuild_manifest might malfunction:
 # fmt: off
@@ -19,7 +19,7 @@ ARCHIVE_KEYS = frozenset(['version', 'name', 'items', 'cmdline', 'hostname', 'us
 # fmt: on
 
 # this is the set of keys that are always present in archives:
-REQUIRED_ARCHIVE_KEYS = frozenset(['version', 'name', 'items', 'cmdline', 'time', ])
+REQUIRED_ARCHIVE_KEYS = frozenset(["version", "name", "items", "cmdline", "time"])
 
 # default umask, overridden by --umask, defaults to read/write only for owner
 UMASK_DEFAULT = 0o077
@@ -28,8 +28,8 @@ UMASK_DEFAULT = 0o077
 # forcing to 0o100XXX later
 STDIN_MODE_DEFAULT = 0o660
 
-CACHE_TAG_NAME = 'CACHEDIR.TAG'
-CACHE_TAG_CONTENTS = b'Signature: 8a477f597d28d172789f06886806bc55'
+CACHE_TAG_NAME = "CACHEDIR.TAG"
+CACHE_TAG_CONTENTS = b"Signature: 8a477f597d28d172789f06886806bc55"
 
 # A large, but not unreasonably large segment size. Always less than 2 GiB (for legacy file systems). We choose
 # 500 MiB which means that no indirection from the inode is needed for typical Linux file systems.
@@ -48,7 +48,7 @@ MAX_DATA_SIZE = 20971479
 MAX_OBJECT_SIZE = MAX_DATA_SIZE + 41 + 8  # see assertion at end of repository module
 
 # repo config max_segment_size value must be below this limit to stay within uint32 offsets:
-MAX_SEGMENT_SIZE_LIMIT = 2 ** 32 - MAX_OBJECT_SIZE
+MAX_SEGMENT_SIZE_LIMIT = 2**32 - MAX_OBJECT_SIZE
 
 # have one all-zero bytes object
 # we use it at all places where we need to detect or create all-zero buffers
@@ -71,12 +71,12 @@ FD_MAX_AGE = 4 * 60  # 4 minutes
 
 CHUNK_MIN_EXP = 19  # 2**19 == 512kiB
 CHUNK_MAX_EXP = 23  # 2**23 == 8MiB
-HASH_WINDOW_SIZE = 0xfff  # 4095B
+HASH_WINDOW_SIZE = 0xFFF  # 4095B
 HASH_MASK_BITS = 21  # results in ~2MiB chunks statistically
 
 # chunker algorithms
-CH_BUZHASH = 'buzhash'
-CH_FIXED = 'fixed'
+CH_BUZHASH = "buzhash"
+CH_FIXED = "fixed"
 
 # defaults, use --chunker-params to override
 CHUNKER_PARAMS = (CH_BUZHASH, CHUNK_MIN_EXP, CHUNK_MAX_EXP, HASH_MASK_BITS, HASH_WINDOW_SIZE)
@@ -88,8 +88,8 @@ ITEMS_CHUNKER_PARAMS = (CH_BUZHASH, 15, 19, 17, HASH_WINDOW_SIZE)
 CH_DATA, CH_ALLOC, CH_HOLE = 0, 1, 2
 
 # operating mode of the files cache (for fast skipping of unchanged files)
-FILES_CACHE_MODE_UI_DEFAULT = 'ctime,size,inode'  # default for "borg create" command (CLI UI)
-FILES_CACHE_MODE_DISABLED = 'd'  # most borg commands do not use the files cache at all (disable)
+FILES_CACHE_MODE_UI_DEFAULT = "ctime,size,inode"  # default for "borg create" command (CLI UI)
+FILES_CACHE_MODE_DISABLED = "d"  # most borg commands do not use the files cache at all (disable)
 
 # return codes returned by borg command
 # when borg is killed by signal N, rc = 128 + N
@@ -101,30 +101,30 @@ EXIT_SIGNAL_BASE = 128  # terminated due to signal, rc = 128 + sig_no
 # never use datetime.isoformat(), it is evil. always use one of these:
 # datetime.strftime(ISO_FORMAT)  # output always includes .microseconds
 # datetime.strftime(ISO_FORMAT_NO_USECS)  # output never includes microseconds
-ISO_FORMAT_NO_USECS = '%Y-%m-%dT%H:%M:%S'
-ISO_FORMAT = ISO_FORMAT_NO_USECS + '.%f'
+ISO_FORMAT_NO_USECS = "%Y-%m-%dT%H:%M:%S"
+ISO_FORMAT = ISO_FORMAT_NO_USECS + ".%f"
 
-DASHES = '-' * 78
+DASHES = "-" * 78
 
 PBKDF2_ITERATIONS = 100000
 
 # https://www.rfc-editor.org/rfc/rfc9106.html#section-4-6.2
-ARGON2_ARGS = {'time_cost': 3, 'memory_cost': 2**16, 'parallelism': 4, 'type': 'id'}
+ARGON2_ARGS = {"time_cost": 3, "memory_cost": 2**16, "parallelism": 4, "type": "id"}
 ARGON2_SALT_BYTES = 16
 
 # Maps the CLI argument to our internal identifier for the format
 KEY_ALGORITHMS = {
     # encrypt-and-MAC, kdf: PBKDF2(HMAC−SHA256), encryption: AES256-CTR, authentication: HMAC-SHA256
-    'pbkdf2': 'sha256',
+    "pbkdf2": "sha256",
     # encrypt-then-MAC, kdf: argon2, encryption: chacha20, authentication: poly1305
-    'argon2': 'argon2 chacha20-poly1305',
+    "argon2": "argon2 chacha20-poly1305",
 }
 
 
 class KeyBlobStorage:
-    NO_STORAGE = 'no_storage'
-    KEYFILE = 'keyfile'
-    REPO = 'repository'
+    NO_STORAGE = "no_storage"
+    KEYFILE = "keyfile"
+    REPO = "repository"
 
 
 class KeyType:
diff --git a/src/borg/crypto/file_integrity.py b/src/borg/crypto/file_integrity.py
index aa2d78d10..e497b6af5 100644
--- a/src/borg/crypto/file_integrity.py
+++ b/src/borg/crypto/file_integrity.py
@@ -102,12 +102,12 @@ class FileHashingWrapper(FileLikeWrapper):
 
 
 class SHA512FileHashingWrapper(FileHashingWrapper):
-    ALGORITHM = 'SHA512'
+    ALGORITHM = "SHA512"
     FACTORY = hashlib.sha512
 
 
 class XXH64FileHashingWrapper(FileHashingWrapper):
-    ALGORITHM = 'XXH64'
+    ALGORITHM = "XXH64"
     FACTORY = StreamingXXH64
 
 
@@ -125,7 +125,7 @@ class IntegrityCheckedFile(FileLikeWrapper):
     def __init__(self, path, write, filename=None, override_fd=None, integrity_data=None):
         self.path = path
         self.writing = write
-        mode = 'wb' if write else 'rb'
+        mode = "wb" if write else "rb"
         self.file_fd = override_fd or open(path, mode)
         self.digests = {}
 
@@ -155,7 +155,7 @@ class IntegrityCheckedFile(FileLikeWrapper):
         # While Borg does not use anything except ASCII in these file names, it's important to use
         # the same encoding everywhere for portability. Using os.fsencode() would be wrong.
         filename = os.path.basename(filename or self.path)
-        self.hasher.update(('%10d' % len(filename)).encode())
+        self.hasher.update(("%10d" % len(filename)).encode())
         self.hasher.update(filename.encode())
 
     @classmethod
@@ -163,44 +163,41 @@ class IntegrityCheckedFile(FileLikeWrapper):
         try:
             integrity_data = json.loads(data)
             # Provisions for agility now, implementation later, but make sure the on-disk joint is oiled.
-            algorithm = integrity_data['algorithm']
+            algorithm = integrity_data["algorithm"]
             if algorithm not in SUPPORTED_ALGORITHMS:
-                logger.warning('Cannot verify integrity of %s: Unknown algorithm %r', path, algorithm)
+                logger.warning("Cannot verify integrity of %s: Unknown algorithm %r", path, algorithm)
                 return
-            digests = integrity_data['digests']
+            digests = integrity_data["digests"]
             # Require at least presence of the final digest
-            digests['final']
+            digests["final"]
             return algorithm, digests
         except (ValueError, TypeError, KeyError) as e:
-            logger.warning('Could not parse integrity data for %s: %s', path, e)
+            logger.warning("Could not parse integrity data for %s: %s", path, e)
             raise FileIntegrityError(path)
 
     def hash_part(self, partname, is_final=False):
         if not self.writing and not self.digests:
             return
-        self.hasher.update(('%10d' % len(partname)).encode())
+        self.hasher.update(("%10d" % len(partname)).encode())
         self.hasher.update(partname.encode())
         self.hasher.hash_length(seek_to_end=is_final)
         digest = self.hasher.hexdigest()
         if self.writing:
             self.digests[partname] = digest
-        elif self.digests and not compare_digest(self.digests.get(partname, ''), digest):
+        elif self.digests and not compare_digest(self.digests.get(partname, ""), digest):
             raise FileIntegrityError(self.path)
 
     def __exit__(self, exc_type, exc_val, exc_tb):
         exception = exc_type is not None
         if not exception:
-            self.hash_part('final', is_final=True)
+            self.hash_part("final", is_final=True)
         self.hasher.__exit__(exc_type, exc_val, exc_tb)
         if exception:
             return
         if self.writing:
-            self.store_integrity_data(json.dumps({
-                'algorithm': self.hasher.ALGORITHM,
-                'digests': self.digests,
-            }))
+            self.store_integrity_data(json.dumps({"algorithm": self.hasher.ALGORITHM, "digests": self.digests}))
         elif self.digests:
-            logger.debug('Verified integrity of %s', self.path)
+            logger.debug("Verified integrity of %s", self.path)
 
     def store_integrity_data(self, data: str):
         self.integrity_data = data
@@ -214,12 +211,12 @@ class DetachedIntegrityCheckedFile(IntegrityCheckedFile):
         self.output_integrity_file = self.integrity_file_path(os.path.join(output_dir, filename))
 
     def load_integrity_data(self, path, integrity_data):
-        assert not integrity_data, 'Cannot pass explicit integrity_data to DetachedIntegrityCheckedFile'
+        assert not integrity_data, "Cannot pass explicit integrity_data to DetachedIntegrityCheckedFile"
         return self.read_integrity_file(self.path)
 
     @staticmethod
     def integrity_file_path(path):
-        return path + '.integrity'
+        return path + ".integrity"
 
     @classmethod
     def read_integrity_file(cls, path):
@@ -227,11 +224,11 @@ class DetachedIntegrityCheckedFile(IntegrityCheckedFile):
             with open(cls.integrity_file_path(path)) as fd:
                 return cls.parse_integrity_data(path, fd.read())
         except FileNotFoundError:
-            logger.info('No integrity file found for %s', path)
+            logger.info("No integrity file found for %s", path)
         except OSError as e:
-            logger.warning('Could not read integrity file for %s: %s', path, e)
+            logger.warning("Could not read integrity file for %s: %s", path, e)
             raise FileIntegrityError(path)
 
     def store_integrity_data(self, data: str):
-        with open(self.output_integrity_file, 'w') as fd:
+        with open(self.output_integrity_file, "w") as fd:
             fd.write(data)
diff --git a/src/borg/crypto/key.py b/src/borg/crypto/key.py
index 94f824942..61a2b5385 100644
--- a/src/borg/crypto/key.py
+++ b/src/borg/crypto/key.py
@@ -59,9 +59,11 @@ class UnsupportedKeyFormatError(Error):
 
 
 class TAMRequiredError(IntegrityError):
-    __doc__ = textwrap.dedent("""
+    __doc__ = textwrap.dedent(
+        """
     Manifest is unauthenticated, but it is required for this repository. Is somebody attacking you?
-    """).strip()
+    """
+    ).strip()
     traceback = False
 
 
@@ -71,11 +73,12 @@ class TAMInvalid(IntegrityError):
 
     def __init__(self):
         # Error message becomes: "Data integrity error: Manifest authentication did not verify"
-        super().__init__('Manifest authentication did not verify')
+        super().__init__("Manifest authentication did not verify")
 
 
 class TAMUnsupportedSuiteError(IntegrityError):
     """Could not verify manifest: Unsupported suite {!r}; a newer version is needed."""
+
     traceback = False
 
 
@@ -110,7 +113,7 @@ def key_factory(repository, manifest_data):
 
 def tam_required_file(repository):
     security_dir = get_security_dir(bin_to_hex(repository.id))
-    return os.path.join(security_dir, 'tam_required')
+    return os.path.join(security_dir, "tam_required")
 
 
 def tam_required(repository):
@@ -126,9 +129,10 @@ def uses_same_id_hash(other_key, key):
     old_blake2_ids = (Blake2RepoKey, Blake2KeyfileKey)
     new_blake2_ids = (Blake2AESOCBRepoKey, Blake2AESOCBKeyfileKey, Blake2CHPORepoKey, Blake2CHPOKeyfileKey)
     same_ids = (
-        isinstance(other_key, old_hmac_sha256_ids + new_hmac_sha256_ids) and isinstance(key, new_hmac_sha256_ids)
-        or
-        isinstance(other_key, old_blake2_ids + new_blake2_ids) and isinstance(key, new_blake2_ids)
+        isinstance(other_key, old_hmac_sha256_ids + new_hmac_sha256_ids)
+        and isinstance(key, new_hmac_sha256_ids)
+        or isinstance(other_key, old_blake2_ids + new_blake2_ids)
+        and isinstance(key, new_blake2_ids)
     )
     return same_ids
 
@@ -140,10 +144,10 @@ class KeyBase:
     TYPES_ACCEPTABLE = None  # override in subclasses
 
     # Human-readable name
-    NAME = 'UNDEFINED'
+    NAME = "UNDEFINED"
 
     # Name used in command line / API (e.g. borg init --encryption=...)
-    ARG_NAME = 'UNDEFINED'
+    ARG_NAME = "UNDEFINED"
 
     # Storage type (no key blob storage / keyfile / repo)
     STORAGE = KeyBlobStorage.NO_STORAGE
@@ -167,13 +171,12 @@ class KeyBase:
         self.target = None  # key location file path / repo obj
         # Some commands write new chunks (e.g. rename) but don't take a --compression argument. This duplicates
         # the default used by those commands who do take a --compression argument.
-        self.compressor = Compressor('lz4')
+        self.compressor = Compressor("lz4")
         self.decompress = self.compressor.decompress
         self.tam_required = True
 
     def id_hash(self, data):
-        """Return HMAC hash using the "id" HMAC key
-        """
+        """Return HMAC hash using the "id" HMAC key"""
         raise NotImplementedError
 
     def encrypt(self, id, data, compress=True):
@@ -186,83 +189,79 @@ class KeyBase:
         if id and id != Manifest.MANIFEST_ID:
             id_computed = self.id_hash(data)
             if not hmac.compare_digest(id_computed, id):
-                raise IntegrityError('Chunk %s: id verification failed' % bin_to_hex(id))
+                raise IntegrityError("Chunk %s: id verification failed" % bin_to_hex(id))
 
     def assert_type(self, type_byte, id=None):
         if type_byte not in self.TYPES_ACCEPTABLE:
-            id_str = bin_to_hex(id) if id is not None else '(unknown)'
-            raise IntegrityError(f'Chunk {id_str}: Invalid encryption envelope')
+            id_str = bin_to_hex(id) if id is not None else "(unknown)"
+            raise IntegrityError(f"Chunk {id_str}: Invalid encryption envelope")
 
     def _tam_key(self, salt, context):
         return hkdf_hmac_sha512(
             ikm=self.id_key + self.enc_key + self.enc_hmac_key,
             salt=salt,
-            info=b'borg-metadata-authentication-' + context,
-            output_length=64
+            info=b"borg-metadata-authentication-" + context,
+            output_length=64,
         )
 
-    def pack_and_authenticate_metadata(self, metadata_dict, context=b'manifest'):
+    def pack_and_authenticate_metadata(self, metadata_dict, context=b"manifest"):
         metadata_dict = StableDict(metadata_dict)
-        tam = metadata_dict['tam'] = StableDict({
-            'type': 'HKDF_HMAC_SHA512',
-            'hmac': bytes(64),
-            'salt': os.urandom(64),
-        })
+        tam = metadata_dict["tam"] = StableDict({"type": "HKDF_HMAC_SHA512", "hmac": bytes(64), "salt": os.urandom(64)})
         packed = msgpack.packb(metadata_dict)
-        tam_key = self._tam_key(tam['salt'], context)
-        tam['hmac'] = hmac.digest(tam_key, packed, 'sha512')
+        tam_key = self._tam_key(tam["salt"], context)
+        tam["hmac"] = hmac.digest(tam_key, packed, "sha512")
         return msgpack.packb(metadata_dict)
 
     def unpack_and_verify_manifest(self, data, force_tam_not_required=False):
         """Unpack msgpacked *data* and return (object, did_verify)."""
-        if data.startswith(b'\xc1' * 4):
+        if data.startswith(b"\xc1" * 4):
             # This is a manifest from the future, we can't read it.
             raise UnsupportedManifestError()
         tam_required = self.tam_required
         if force_tam_not_required and tam_required:
-            logger.warning('Manifest authentication DISABLED.')
+            logger.warning("Manifest authentication DISABLED.")
             tam_required = False
         data = bytearray(data)
-        unpacker = get_limited_unpacker('manifest')
+        unpacker = get_limited_unpacker("manifest")
         unpacker.feed(data)
         unpacked = unpacker.unpack()
-        if 'tam' not in unpacked:
+        if "tam" not in unpacked:
             if tam_required:
                 raise TAMRequiredError(self.repository._location.canonical_path())
             else:
-                logger.debug('TAM not found and not required')
+                logger.debug("TAM not found and not required")
                 return unpacked, False
-        tam = unpacked.pop('tam', None)
+        tam = unpacked.pop("tam", None)
         if not isinstance(tam, dict):
             raise TAMInvalid()
-        tam_type = tam.get('type', '<none>')
-        if tam_type != 'HKDF_HMAC_SHA512':
+        tam_type = tam.get("type", "<none>")
+        if tam_type != "HKDF_HMAC_SHA512":
             if tam_required:
                 raise TAMUnsupportedSuiteError(repr(tam_type))
             else:
-                logger.debug('Ignoring TAM made with unsupported suite, since TAM is not required: %r', tam_type)
+                logger.debug("Ignoring TAM made with unsupported suite, since TAM is not required: %r", tam_type)
                 return unpacked, False
-        tam_hmac = tam.get('hmac')
-        tam_salt = tam.get('salt')
+        tam_hmac = tam.get("hmac")
+        tam_salt = tam.get("salt")
         if not isinstance(tam_salt, (bytes, str)) or not isinstance(tam_hmac, (bytes, str)):
             raise TAMInvalid()
         tam_hmac = want_bytes(tam_hmac)  # legacy
         tam_salt = want_bytes(tam_salt)  # legacy
         offset = data.index(tam_hmac)
-        data[offset:offset + 64] = bytes(64)
-        tam_key = self._tam_key(tam_salt, context=b'manifest')
-        calculated_hmac = hmac.digest(tam_key, data, 'sha512')
+        data[offset : offset + 64] = bytes(64)
+        tam_key = self._tam_key(tam_salt, context=b"manifest")
+        calculated_hmac = hmac.digest(tam_key, data, "sha512")
         if not hmac.compare_digest(calculated_hmac, tam_hmac):
             raise TAMInvalid()
-        logger.debug('TAM-verified manifest')
+        logger.debug("TAM-verified manifest")
         return unpacked, True
 
 
 class PlaintextKey(KeyBase):
     TYPE = KeyType.PLAINTEXT
     TYPES_ACCEPTABLE = {TYPE}
-    NAME = 'plaintext'
-    ARG_NAME = 'none'
+    NAME = "plaintext"
+    ARG_NAME = "none"
     STORAGE = KeyBlobStorage.NO_STORAGE
 
     chunk_seed = 0
@@ -287,7 +286,7 @@ class PlaintextKey(KeyBase):
     def encrypt(self, id, data, compress=True):
         if compress:
             data = self.compressor.compress(data)
-        return b''.join([self.TYPE_STR, data])
+        return b"".join([self.TYPE_STR, data])
 
     def decrypt(self, id, data, decompress=True):
         self.assert_type(data[0], id)
@@ -364,8 +363,7 @@ class AESKeyBase(KeyBase):
     def encrypt(self, id, data, compress=True):
         if compress:
             data = self.compressor.compress(data)
-        next_iv = self.nonce_manager.ensure_reservation(self.cipher.next_iv(),
-                                                        self.cipher.block_count(len(data)))
+        next_iv = self.nonce_manager.ensure_reservation(self.cipher.next_iv(), self.cipher.block_count(len(data)))
         return self.cipher.encrypt(data, header=self.TYPE_STR, iv=next_iv)
 
     def decrypt(self, id, data, decompress=True):
@@ -395,12 +393,10 @@ class AESKeyBase(KeyBase):
         chunk_seed = bytes_to_int(data[96:100])
         # Convert to signed int32
         if chunk_seed & 0x80000000:
-            chunk_seed = chunk_seed - 0xffffffff - 1
+            chunk_seed = chunk_seed - 0xFFFFFFFF - 1
         self.init_from_given_data(
-            enc_key=data[0:32],
-            enc_hmac_key=data[32:64],
-            id_key=data[64:96],
-            chunk_seed=chunk_seed)
+            enc_key=data[0:32], enc_hmac_key=data[32:64], id_key=data[64:96], chunk_seed=chunk_seed
+        )
 
     def init_ciphers(self, manifest_data=None):
         self.cipher = self.CIPHERSUITE(mac_key=self.enc_hmac_key, enc_key=self.enc_key, header_len=1, aad_offset=1)
@@ -418,13 +414,13 @@ class AESKeyBase(KeyBase):
 
 
 class FlexiKey:
-    FILE_ID = 'BORG_KEY'
+    FILE_ID = "BORG_KEY"
 
     @classmethod
     def detect(cls, repository, manifest_data):
         key = cls(repository)
         target = key.find_key()
-        prompt = 'Enter passphrase for key %s: ' % target
+        prompt = "Enter passphrase for key %s: " % target
         passphrase = Passphrase.env_passphrase()
         if passphrase is None:
             passphrase = Passphrase()
@@ -449,18 +445,18 @@ class FlexiKey:
             data = msgpack.unpackb(data)
             key = Key(internal_dict=data)
             if key.version != 1:
-                raise IntegrityError('Invalid key file header')
+                raise IntegrityError("Invalid key file header")
             self.repository_id = key.repository_id
             self.enc_key = key.enc_key
             self.enc_hmac_key = key.enc_hmac_key
             self.id_key = key.id_key
             self.chunk_seed = key.chunk_seed
-            self.tam_required = key.get('tam_required', tam_required(self.repository))
+            self.tam_required = key.get("tam_required", tam_required(self.repository))
             return True
         return False
 
     def decrypt_key_file(self, data, passphrase):
-        unpacker = get_limited_unpacker('key')
+        unpacker = get_limited_unpacker("key")
         unpacker.feed(data)
         data = unpacker.unpack()
         encrypted_key = EncryptedKey(internal_dict=data)
@@ -468,9 +464,9 @@ class FlexiKey:
             raise UnsupportedKeyFormatError()
         else:
             self._encrypted_key_algorithm = encrypted_key.algorithm
-            if encrypted_key.algorithm == 'sha256':
+            if encrypted_key.algorithm == "sha256":
                 return self.decrypt_key_file_pbkdf2(encrypted_key, passphrase)
-            elif encrypted_key.algorithm == 'argon2 chacha20-poly1305':
+            elif encrypted_key.algorithm == "argon2 chacha20-poly1305":
                 return self.decrypt_key_file_argon2(encrypted_key, passphrase)
             else:
                 raise UnsupportedKeyFormatError()
@@ -479,7 +475,7 @@ class FlexiKey:
     def pbkdf2(passphrase, salt, iterations, output_len_in_bytes):
         if os.environ.get("BORG_TESTONLY_WEAKEN_KDF") == "1":
             iterations = 1
-        return pbkdf2_hmac('sha256', passphrase.encode('utf-8'), salt, iterations, output_len_in_bytes)
+        return pbkdf2_hmac("sha256", passphrase.encode("utf-8"), salt, iterations, output_len_in_bytes)
 
     @staticmethod
     def argon2(
@@ -489,18 +485,14 @@ class FlexiKey:
         time_cost: int,
         memory_cost: int,
         parallelism: int,
-        type: Literal['i', 'd', 'id']
+        type: Literal["i", "d", "id"],
     ) -> bytes:
         if os.environ.get("BORG_TESTONLY_WEAKEN_KDF") == "1":
             time_cost = 1
             parallelism = 1
             # 8 is the smallest value that avoids the "Memory cost is too small" exception
             memory_cost = 8
-        type_map = {
-            'i': argon2.low_level.Type.I,
-            'd': argon2.low_level.Type.D,
-            'id': argon2.low_level.Type.ID,
-        }
+        type_map = {"i": argon2.low_level.Type.I, "d": argon2.low_level.Type.D, "id": argon2.low_level.Type.ID}
         key = argon2.low_level.hash_secret_raw(
             secret=passphrase.encode("utf-8"),
             hash_len=output_len_in_bytes,
@@ -514,7 +506,7 @@ class FlexiKey:
 
     def decrypt_key_file_pbkdf2(self, encrypted_key, passphrase):
         key = self.pbkdf2(passphrase, encrypted_key.salt, encrypted_key.iterations, 32)
-        data = AES(key, b'\0'*16).decrypt(encrypted_key.data)
+        data = AES(key, b"\0" * 16).decrypt(encrypted_key.data)
         if hmac.compare_digest(hmac_sha256(key, data), encrypted_key.hash):
             return data
         return None
@@ -536,44 +528,32 @@ class FlexiKey:
             return None
 
     def encrypt_key_file(self, data, passphrase, algorithm):
-        if algorithm == 'sha256':
+        if algorithm == "sha256":
             return self.encrypt_key_file_pbkdf2(data, passphrase)
-        elif algorithm == 'argon2 chacha20-poly1305':
+        elif algorithm == "argon2 chacha20-poly1305":
             return self.encrypt_key_file_argon2(data, passphrase)
         else:
-            raise ValueError(f'Unexpected algorithm: {algorithm}')
+            raise ValueError(f"Unexpected algorithm: {algorithm}")
 
     def encrypt_key_file_pbkdf2(self, data, passphrase):
         salt = os.urandom(32)
         iterations = PBKDF2_ITERATIONS
         key = self.pbkdf2(passphrase, salt, iterations, 32)
         hash = hmac_sha256(key, data)
-        cdata = AES(key, b'\0'*16).encrypt(data)
-        enc_key = EncryptedKey(
-            version=1,
-            salt=salt,
-            iterations=iterations,
-            algorithm='sha256',
-            hash=hash,
-            data=cdata,
-        )
+        cdata = AES(key, b"\0" * 16).encrypt(data)
+        enc_key = EncryptedKey(version=1, salt=salt, iterations=iterations, algorithm="sha256", hash=hash, data=cdata)
         return msgpack.packb(enc_key.as_dict())
 
     def encrypt_key_file_argon2(self, data, passphrase):
         salt = os.urandom(ARGON2_SALT_BYTES)
-        key = self.argon2(
-            passphrase,
-            output_len_in_bytes=32,
-            salt=salt,
-            **ARGON2_ARGS,
-        )
+        key = self.argon2(passphrase, output_len_in_bytes=32, salt=salt, **ARGON2_ARGS)
         ae_cipher = CHACHA20_POLY1305(key=key, iv=0, header_len=0, aad_offset=0)
         encrypted_key = EncryptedKey(
             version=1,
-            algorithm='argon2 chacha20-poly1305',
+            algorithm="argon2 chacha20-poly1305",
             salt=salt,
             data=ae_cipher.encrypt(data),
-            **{'argon2_' + k: v for k, v in ARGON2_ARGS.items()},
+            **{"argon2_" + k: v for k, v in ARGON2_ARGS.items()},
         )
         return msgpack.packb(encrypted_key.as_dict())
 
@@ -588,7 +568,7 @@ class FlexiKey:
             tam_required=self.tam_required,
         )
         data = self.encrypt_key_file(msgpack.packb(key.as_dict()), passphrase, algorithm)
-        key_data = '\n'.join(textwrap.wrap(b2a_base64(data).decode('ascii')))
+        key_data = "\n".join(textwrap.wrap(b2a_base64(data).decode("ascii")))
         return key_data
 
     def change_passphrase(self, passphrase=None):
@@ -612,22 +592,23 @@ class FlexiKey:
                 enc_key=other_key.enc_key,
                 enc_hmac_key=other_key.enc_hmac_key,
                 id_key=other_key.id_key,
-                chunk_seed=other_key.chunk_seed)
+                chunk_seed=other_key.chunk_seed,
+            )
             passphrase = other_key._passphrase
         else:
             key.init_from_random_data()
             passphrase = Passphrase.new(allow_empty=True)
         key.init_ciphers()
         target = key.get_new_target(args)
-        key.save(target, passphrase, create=True, algorithm=KEY_ALGORITHMS['argon2'])
+        key.save(target, passphrase, create=True, algorithm=KEY_ALGORITHMS["argon2"])
         logger.info('Key in "%s" created.' % target)
-        logger.info('Keep this key safe. Your data will be inaccessible without it.')
+        logger.info("Keep this key safe. Your data will be inaccessible without it.")
         return key
 
     def sanity_check(self, filename, id):
-        file_id = self.FILE_ID.encode() + b' '
+        file_id = self.FILE_ID.encode() + b" "
         repo_id = hexlify(id)
-        with open(filename, 'rb') as fd:
+        with open(filename, "rb") as fd:
             # we do the magic / id check in binary mode to avoid stumbling over
             # decoding errors if somebody has binary files in the keys dir for some reason.
             if fd.read(len(file_id)) != file_id:
@@ -653,7 +634,7 @@ class FlexiKey:
                 raise RepoKeyNotFoundError(loc) from None
             return loc
         else:
-            raise TypeError('Unsupported borg key storage type')
+            raise TypeError("Unsupported borg key storage type")
 
     def get_existing_or_new_target(self, args):
         keyfile = self._find_key_file_from_environment()
@@ -683,10 +664,10 @@ class FlexiKey:
         elif self.STORAGE == KeyBlobStorage.REPO:
             return self.repository
         else:
-            raise TypeError('Unsupported borg key storage type')
+            raise TypeError("Unsupported borg key storage type")
 
     def _find_key_file_from_environment(self):
-        keyfile = os.environ.get('BORG_KEY_FILE')
+        keyfile = os.environ.get("BORG_KEY_FILE")
         if keyfile:
             return os.path.abspath(keyfile)
 
@@ -696,17 +677,17 @@ class FlexiKey:
         i = 1
         while os.path.exists(path):
             i += 1
-            path = filename + '.%d' % i
+            path = filename + ".%d" % i
         return path
 
     def load(self, target, passphrase):
         if self.STORAGE == KeyBlobStorage.KEYFILE:
             with open(target) as fd:
-                key_data = ''.join(fd.readlines()[1:])
+                key_data = "".join(fd.readlines()[1:])
         elif self.STORAGE == KeyBlobStorage.REPO:
             # While the repository is encrypted, we consider a repokey repository with a blank
             # passphrase an unencrypted repository.
-            self.logically_encrypted = passphrase != ''
+            self.logically_encrypted = passphrase != ""
 
             # what we get in target is just a repo location, but we already have the repo obj:
             target = self.repository
@@ -715,9 +696,9 @@ class FlexiKey:
                 # if we got an empty key, it means there is no key.
                 loc = target._location.canonical_path()
                 raise RepoKeyNotFoundError(loc) from None
-            key_data = key_data.decode('utf-8')  # remote repo: msgpack issue #99, getting bytes
+            key_data = key_data.decode("utf-8")  # remote repo: msgpack issue #99, getting bytes
         else:
-            raise TypeError('Unsupported borg key storage type')
+            raise TypeError("Unsupported borg key storage type")
         success = self._load(key_data, passphrase)
         if success:
             self.target = target
@@ -732,31 +713,31 @@ class FlexiKey:
                 # see issue #6036
                 raise Error('Aborting because key in "%s" already exists.' % target)
             with SaveFile(target) as fd:
-                fd.write(f'{self.FILE_ID} {bin_to_hex(self.repository_id)}\n')
+                fd.write(f"{self.FILE_ID} {bin_to_hex(self.repository_id)}\n")
                 fd.write(key_data)
-                fd.write('\n')
+                fd.write("\n")
         elif self.STORAGE == KeyBlobStorage.REPO:
-            self.logically_encrypted = passphrase != ''
-            key_data = key_data.encode('utf-8')  # remote repo: msgpack issue #99, giving bytes
+            self.logically_encrypted = passphrase != ""
+            key_data = key_data.encode("utf-8")  # remote repo: msgpack issue #99, giving bytes
             target.save_key(key_data)
         else:
-            raise TypeError('Unsupported borg key storage type')
+            raise TypeError("Unsupported borg key storage type")
         self.target = target
 
     def remove(self, target):
         if self.STORAGE == KeyBlobStorage.KEYFILE:
             os.remove(target)
         elif self.STORAGE == KeyBlobStorage.REPO:
-            target.save_key(b'')  # save empty key (no new api at remote repo necessary)
+            target.save_key(b"")  # save empty key (no new api at remote repo necessary)
         else:
-            raise TypeError('Unsupported borg key storage type')
+            raise TypeError("Unsupported borg key storage type")
 
 
 class KeyfileKey(ID_HMAC_SHA_256, AESKeyBase, FlexiKey):
     TYPES_ACCEPTABLE = {KeyType.KEYFILE, KeyType.REPO, KeyType.PASSPHRASE}
     TYPE = KeyType.KEYFILE
-    NAME = 'key file'
-    ARG_NAME = 'keyfile'
+    NAME = "key file"
+    ARG_NAME = "keyfile"
     STORAGE = KeyBlobStorage.KEYFILE
     CIPHERSUITE = AES256_CTR_HMAC_SHA256
 
@@ -764,8 +745,8 @@ class KeyfileKey(ID_HMAC_SHA_256, AESKeyBase, FlexiKey):
 class RepoKey(ID_HMAC_SHA_256, AESKeyBase, FlexiKey):
     TYPES_ACCEPTABLE = {KeyType.KEYFILE, KeyType.REPO, KeyType.PASSPHRASE}
     TYPE = KeyType.REPO
-    NAME = 'repokey'
-    ARG_NAME = 'repokey'
+    NAME = "repokey"
+    ARG_NAME = "repokey"
     STORAGE = KeyBlobStorage.REPO
     CIPHERSUITE = AES256_CTR_HMAC_SHA256
 
@@ -773,8 +754,8 @@ class RepoKey(ID_HMAC_SHA_256, AESKeyBase, FlexiKey):
 class Blake2KeyfileKey(ID_BLAKE2b_256, AESKeyBase, FlexiKey):
     TYPES_ACCEPTABLE = {KeyType.BLAKE2KEYFILE, KeyType.BLAKE2REPO}
     TYPE = KeyType.BLAKE2KEYFILE
-    NAME = 'key file BLAKE2b'
-    ARG_NAME = 'keyfile-blake2'
+    NAME = "key file BLAKE2b"
+    ARG_NAME = "keyfile-blake2"
     STORAGE = KeyBlobStorage.KEYFILE
     CIPHERSUITE = AES256_CTR_BLAKE2b
 
@@ -782,8 +763,8 @@ class Blake2KeyfileKey(ID_BLAKE2b_256, AESKeyBase, FlexiKey):
 class Blake2RepoKey(ID_BLAKE2b_256, AESKeyBase, FlexiKey):
     TYPES_ACCEPTABLE = {KeyType.BLAKE2KEYFILE, KeyType.BLAKE2REPO}
     TYPE = KeyType.BLAKE2REPO
-    NAME = 'repokey BLAKE2b'
-    ARG_NAME = 'repokey-blake2'
+    NAME = "repokey BLAKE2b"
+    ARG_NAME = "repokey-blake2"
     STORAGE = KeyBlobStorage.REPO
     CIPHERSUITE = AES256_CTR_BLAKE2b
 
@@ -810,7 +791,7 @@ class AuthenticatedKeyBase(AESKeyBase, FlexiKey):
     def encrypt(self, id, data, compress=True):
         if compress:
             data = self.compressor.compress(data)
-        return b''.join([self.TYPE_STR, data])
+        return b"".join([self.TYPE_STR, data])
 
     def decrypt(self, id, data, decompress=True):
         self.assert_type(data[0], id)
@@ -825,15 +806,15 @@ class AuthenticatedKeyBase(AESKeyBase, FlexiKey):
 class AuthenticatedKey(ID_HMAC_SHA_256, AuthenticatedKeyBase):
     TYPE = KeyType.AUTHENTICATED
     TYPES_ACCEPTABLE = {TYPE}
-    NAME = 'authenticated'
-    ARG_NAME = 'authenticated'
+    NAME = "authenticated"
+    ARG_NAME = "authenticated"
 
 
 class Blake2AuthenticatedKey(ID_BLAKE2b_256, AuthenticatedKeyBase):
     TYPE = KeyType.BLAKE2AUTHENTICATED
     TYPES_ACCEPTABLE = {TYPE}
-    NAME = 'authenticated BLAKE2b'
-    ARG_NAME = 'authenticated-blake2'
+    NAME = "authenticated BLAKE2b"
+    ARG_NAME = "authenticated-blake2"
 
 
 # ------------ new crypto ------------
@@ -862,17 +843,17 @@ class AEADKeyBase(KeyBase):
 
     logically_encrypted = True
 
-    MAX_IV = 2 ** 48 - 1
+    MAX_IV = 2**48 - 1
 
     def encrypt(self, id, data, compress=True):
         # to encrypt new data in this session we use always self.cipher and self.sessionid
         if compress:
             data = self.compressor.compress(data)
-        reserved = b'\0'
+        reserved = b"\0"
         iv = self.cipher.next_iv()
         if iv > self.MAX_IV:  # see the data-structures docs about why the IV range is enough
             raise IntegrityError("IV overflow, should never happen.")
-        iv_48bit = iv.to_bytes(6, 'big')
+        iv_48bit = iv.to_bytes(6, "big")
         header = self.TYPE_STR + reserved + iv_48bit + self.sessionid
         return self.cipher.encrypt(data, header=header, iv=iv, aad=id)
 
@@ -881,7 +862,7 @@ class AEADKeyBase(KeyBase):
         self.assert_type(data[0], id)
         iv_48bit = data[2:8]
         sessionid = data[8:32]
-        iv = int.from_bytes(iv_48bit, 'big')
+        iv = int.from_bytes(iv_48bit, "big")
         cipher = self._get_cipher(sessionid, iv)
         try:
             payload = cipher.decrypt(data, aad=id)
@@ -908,27 +889,25 @@ class AEADKeyBase(KeyBase):
         chunk_seed = bytes_to_int(data[96:100])
         # Convert to signed int32
         if chunk_seed & 0x80000000:
-            chunk_seed = chunk_seed - 0xffffffff - 1
+            chunk_seed = chunk_seed - 0xFFFFFFFF - 1
         self.init_from_given_data(
-            enc_key=data[0:32],
-            enc_hmac_key=data[32:64],
-            id_key=data[64:96],
-            chunk_seed=chunk_seed)
+            enc_key=data[0:32], enc_hmac_key=data[32:64], id_key=data[64:96], chunk_seed=chunk_seed
+        )
 
     def _get_session_key(self, sessionid):
         assert len(sessionid) == 24  # 192bit
         key = hkdf_hmac_sha512(
             ikm=self.enc_key + self.enc_hmac_key,
             salt=sessionid,
-            info=b'borg-session-key-' + self.CIPHERSUITE.__name__.encode(),
-            output_length=32
+            info=b"borg-session-key-" + self.CIPHERSUITE.__name__.encode(),
+            output_length=32,
         )
         return key
 
     def _get_cipher(self, sessionid, iv):
         assert isinstance(iv, int)
         key = self._get_session_key(sessionid)
-        cipher = self.CIPHERSUITE(key=key, iv=iv, header_len=1+1+6+24, aad_offset=0)
+        cipher = self.CIPHERSUITE(key=key, iv=iv, header_len=1 + 1 + 6 + 24, aad_offset=0)
         return cipher
 
     def init_ciphers(self, manifest_data=None, iv=0):
@@ -940,8 +919,8 @@ class AEADKeyBase(KeyBase):
 class AESOCBKeyfileKey(ID_HMAC_SHA_256, AEADKeyBase, FlexiKey):
     TYPES_ACCEPTABLE = {KeyType.AESOCBKEYFILE, KeyType.AESOCBREPO}
     TYPE = KeyType.AESOCBKEYFILE
-    NAME = 'key file AES-OCB'
-    ARG_NAME = 'keyfile-aes-ocb'
+    NAME = "key file AES-OCB"
+    ARG_NAME = "keyfile-aes-ocb"
     STORAGE = KeyBlobStorage.KEYFILE
     CIPHERSUITE = AES256_OCB
 
@@ -949,8 +928,8 @@ class AESOCBKeyfileKey(ID_HMAC_SHA_256, AEADKeyBase, FlexiKey):
 class AESOCBRepoKey(ID_HMAC_SHA_256, AEADKeyBase, FlexiKey):
     TYPES_ACCEPTABLE = {KeyType.AESOCBKEYFILE, KeyType.AESOCBREPO}
     TYPE = KeyType.AESOCBREPO
-    NAME = 'repokey AES-OCB'
-    ARG_NAME = 'repokey-aes-ocb'
+    NAME = "repokey AES-OCB"
+    ARG_NAME = "repokey-aes-ocb"
     STORAGE = KeyBlobStorage.REPO
     CIPHERSUITE = AES256_OCB
 
@@ -958,8 +937,8 @@ class AESOCBRepoKey(ID_HMAC_SHA_256, AEADKeyBase, FlexiKey):
 class CHPOKeyfileKey(ID_HMAC_SHA_256, AEADKeyBase, FlexiKey):
     TYPES_ACCEPTABLE = {KeyType.CHPOKEYFILE, KeyType.CHPOREPO}
     TYPE = KeyType.CHPOKEYFILE
-    NAME = 'key file ChaCha20-Poly1305'
-    ARG_NAME = 'keyfile-chacha20-poly1305'
+    NAME = "key file ChaCha20-Poly1305"
+    ARG_NAME = "keyfile-chacha20-poly1305"
     STORAGE = KeyBlobStorage.KEYFILE
     CIPHERSUITE = CHACHA20_POLY1305
 
@@ -967,8 +946,8 @@ class CHPOKeyfileKey(ID_HMAC_SHA_256, AEADKeyBase, FlexiKey):
 class CHPORepoKey(ID_HMAC_SHA_256, AEADKeyBase, FlexiKey):
     TYPES_ACCEPTABLE = {KeyType.CHPOKEYFILE, KeyType.CHPOREPO}
     TYPE = KeyType.CHPOREPO
-    NAME = 'repokey ChaCha20-Poly1305'
-    ARG_NAME = 'repokey-chacha20-poly1305'
+    NAME = "repokey ChaCha20-Poly1305"
+    ARG_NAME = "repokey-chacha20-poly1305"
     STORAGE = KeyBlobStorage.REPO
     CIPHERSUITE = CHACHA20_POLY1305
 
@@ -976,8 +955,8 @@ class CHPORepoKey(ID_HMAC_SHA_256, AEADKeyBase, FlexiKey):
 class Blake2AESOCBKeyfileKey(ID_BLAKE2b_256, AEADKeyBase, FlexiKey):
     TYPES_ACCEPTABLE = {KeyType.BLAKE2AESOCBKEYFILE, KeyType.BLAKE2AESOCBREPO}
     TYPE = KeyType.BLAKE2AESOCBKEYFILE
-    NAME = 'key file BLAKE2b AES-OCB'
-    ARG_NAME = 'keyfile-blake2-aes-ocb'
+    NAME = "key file BLAKE2b AES-OCB"
+    ARG_NAME = "keyfile-blake2-aes-ocb"
     STORAGE = KeyBlobStorage.KEYFILE
     CIPHERSUITE = AES256_OCB
 
@@ -985,8 +964,8 @@ class Blake2AESOCBKeyfileKey(ID_BLAKE2b_256, AEADKeyBase, FlexiKey):
 class Blake2AESOCBRepoKey(ID_BLAKE2b_256, AEADKeyBase, FlexiKey):
     TYPES_ACCEPTABLE = {KeyType.BLAKE2AESOCBKEYFILE, KeyType.BLAKE2AESOCBREPO}
     TYPE = KeyType.BLAKE2AESOCBREPO
-    NAME = 'repokey BLAKE2b AES-OCB'
-    ARG_NAME = 'repokey-blake2-aes-ocb'
+    NAME = "repokey BLAKE2b AES-OCB"
+    ARG_NAME = "repokey-blake2-aes-ocb"
     STORAGE = KeyBlobStorage.REPO
     CIPHERSUITE = AES256_OCB
 
@@ -994,8 +973,8 @@ class Blake2AESOCBRepoKey(ID_BLAKE2b_256, AEADKeyBase, FlexiKey):
 class Blake2CHPOKeyfileKey(ID_BLAKE2b_256, AEADKeyBase, FlexiKey):
     TYPES_ACCEPTABLE = {KeyType.BLAKE2CHPOKEYFILE, KeyType.BLAKE2CHPOREPO}
     TYPE = KeyType.BLAKE2CHPOKEYFILE
-    NAME = 'key file BLAKE2b ChaCha20-Poly1305'
-    ARG_NAME = 'keyfile-blake2-chacha20-poly1305'
+    NAME = "key file BLAKE2b ChaCha20-Poly1305"
+    ARG_NAME = "keyfile-blake2-chacha20-poly1305"
     STORAGE = KeyBlobStorage.KEYFILE
     CIPHERSUITE = CHACHA20_POLY1305
 
@@ -1003,26 +982,33 @@ class Blake2CHPOKeyfileKey(ID_BLAKE2b_256, AEADKeyBase, FlexiKey):
 class Blake2CHPORepoKey(ID_BLAKE2b_256, AEADKeyBase, FlexiKey):
     TYPES_ACCEPTABLE = {KeyType.BLAKE2CHPOKEYFILE, KeyType.BLAKE2CHPOREPO}
     TYPE = KeyType.BLAKE2CHPOREPO
-    NAME = 'repokey BLAKE2b ChaCha20-Poly1305'
-    ARG_NAME = 'repokey-blake2-chacha20-poly1305'
+    NAME = "repokey BLAKE2b ChaCha20-Poly1305"
+    ARG_NAME = "repokey-blake2-chacha20-poly1305"
     STORAGE = KeyBlobStorage.REPO
     CIPHERSUITE = CHACHA20_POLY1305
 
 
 LEGACY_KEY_TYPES = (
     # legacy (AES-CTR based) crypto
-    KeyfileKey, RepoKey,
-    Blake2KeyfileKey, Blake2RepoKey,
+    KeyfileKey,
+    RepoKey,
+    Blake2KeyfileKey,
+    Blake2RepoKey,
 )
 
 AVAILABLE_KEY_TYPES = (
     # these are available encryption modes for new repositories
     # not encrypted modes
     PlaintextKey,
-    AuthenticatedKey, Blake2AuthenticatedKey,
+    AuthenticatedKey,
+    Blake2AuthenticatedKey,
     # new crypto
-    AESOCBKeyfileKey, AESOCBRepoKey,
-    CHPOKeyfileKey, CHPORepoKey,
-    Blake2AESOCBKeyfileKey, Blake2AESOCBRepoKey,
-    Blake2CHPOKeyfileKey, Blake2CHPORepoKey,
+    AESOCBKeyfileKey,
+    AESOCBRepoKey,
+    CHPOKeyfileKey,
+    CHPORepoKey,
+    Blake2AESOCBKeyfileKey,
+    Blake2AESOCBRepoKey,
+    Blake2CHPOKeyfileKey,
+    Blake2CHPORepoKey,
 )
diff --git a/src/borg/crypto/keymanager.py b/src/borg/crypto/keymanager.py
index 715d451a1..552134096 100644
--- a/src/borg/crypto/keymanager.py
+++ b/src/borg/crypto/keymanager.py
@@ -53,7 +53,7 @@ class KeyManager:
             k = CHPOKeyfileKey(self.repository)
             target = k.find_key()
             with open(target) as fd:
-                self.keyblob = ''.join(fd.readlines()[1:])
+                self.keyblob = "".join(fd.readlines()[1:])
 
         elif self.keyblob_storage == KeyBlobStorage.REPO:
             key_data = self.repository.load_key().decode()
@@ -70,75 +70,77 @@ class KeyManager:
 
             self.store_keyfile(target)
         elif self.keyblob_storage == KeyBlobStorage.REPO:
-            self.repository.save_key(self.keyblob.encode('utf-8'))
+            self.repository.save_key(self.keyblob.encode("utf-8"))
 
     def get_keyfile_data(self):
-        data = f'{CHPOKeyfileKey.FILE_ID} {bin_to_hex(self.repository.id)}\n'
+        data = f"{CHPOKeyfileKey.FILE_ID} {bin_to_hex(self.repository.id)}\n"
         data += self.keyblob
-        if not self.keyblob.endswith('\n'):
-            data += '\n'
+        if not self.keyblob.endswith("\n"):
+            data += "\n"
         return data
 
     def store_keyfile(self, target):
-        with dash_open(target, 'w') as fd:
+        with dash_open(target, "w") as fd:
             fd.write(self.get_keyfile_data())
 
     def export(self, path):
         if path is None:
-            path = '-'
+            path = "-"
 
         self.store_keyfile(path)
 
     def export_qr(self, path):
         if path is None:
-            path = '-'
+            path = "-"
 
-        with dash_open(path, 'wb') as fd:
+        with dash_open(path, "wb") as fd:
             key_data = self.get_keyfile_data()
-            html = pkgutil.get_data('borg', 'paperkey.html')
-            html = html.replace(b'</textarea>', key_data.encode() + b'</textarea>')
+            html = pkgutil.get_data("borg", "paperkey.html")
+            html = html.replace(b"</textarea>", key_data.encode() + b"</textarea>")
             fd.write(html)
 
     def export_paperkey(self, path):
         if path is None:
-            path = '-'
+            path = "-"
 
         def grouped(s):
-            ret = ''
+            ret = ""
             i = 0
             for ch in s:
                 if i and i % 6 == 0:
-                    ret += ' '
+                    ret += " "
                 ret += ch
                 i += 1
             return ret
 
-        export = 'To restore key use borg key import --paper /path/to/repo\n\n'
+        export = "To restore key use borg key import --paper /path/to/repo\n\n"
 
         binary = a2b_base64(self.keyblob)
-        export += 'BORG PAPER KEY v1\n'
+        export += "BORG PAPER KEY v1\n"
         lines = (len(binary) + 17) // 18
         repoid = bin_to_hex(self.repository.id)[:18]
         complete_checksum = sha256_truncated(binary, 12)
-        export += 'id: {:d} / {} / {} - {}\n'.format(lines,
-                                       grouped(repoid),
-                                       grouped(complete_checksum),
-                                       sha256_truncated((str(lines) + '/' + repoid + '/' + complete_checksum).encode('ascii'), 2))
+        export += "id: {:d} / {} / {} - {}\n".format(
+            lines,
+            grouped(repoid),
+            grouped(complete_checksum),
+            sha256_truncated((str(lines) + "/" + repoid + "/" + complete_checksum).encode("ascii"), 2),
+        )
         idx = 0
         while len(binary):
             idx += 1
             binline = binary[:18]
-            checksum = sha256_truncated(idx.to_bytes(2, byteorder='big') + binline, 2)
-            export += f'{idx:2d}: {grouped(bin_to_hex(binline))} - {checksum}\n'
+            checksum = sha256_truncated(idx.to_bytes(2, byteorder="big") + binline, 2)
+            export += f"{idx:2d}: {grouped(bin_to_hex(binline))} - {checksum}\n"
             binary = binary[18:]
 
-        with dash_open(path, 'w') as fd:
+        with dash_open(path, "w") as fd:
             fd.write(export)
 
     def import_keyfile(self, args):
         file_id = CHPOKeyfileKey.FILE_ID
-        first_line = file_id + ' ' + bin_to_hex(self.repository.id) + '\n'
-        with dash_open(args.path, 'r') as fd:
+        first_line = file_id + " " + bin_to_hex(self.repository.id) + "\n"
+        with dash_open(args.path, "r") as fd:
             file_first_line = fd.read(len(first_line))
             if file_first_line != first_line:
                 if not file_first_line.startswith(file_id):
@@ -154,52 +156,52 @@ class KeyManager:
             # imported here because it has global side effects
             import readline
         except ImportError:
-            print('Note: No line editing available due to missing readline support')
+            print("Note: No line editing available due to missing readline support")
 
         repoid = bin_to_hex(self.repository.id)[:18]
         try:
             while True:  # used for repeating on overall checksum mismatch
                 # id line input
                 while True:
-                    idline = input('id: ').replace(' ', '')
-                    if idline == '':
-                        if yes('Abort import? [yN]:'):
+                    idline = input("id: ").replace(" ", "")
+                    if idline == "":
+                        if yes("Abort import? [yN]:"):
                             raise EOFError()
 
                     try:
-                        (data, checksum) = idline.split('-')
+                        (data, checksum) = idline.split("-")
                     except ValueError:
                         print("each line must contain exactly one '-', try again")
                         continue
                     try:
-                        (id_lines, id_repoid, id_complete_checksum) = data.split('/')
+                        (id_lines, id_repoid, id_complete_checksum) = data.split("/")
                     except ValueError:
                         print("the id line must contain exactly three '/', try again")
                         continue
-                    if sha256_truncated(data.lower().encode('ascii'), 2) != checksum:
-                        print('line checksum did not match, try same line again')
+                    if sha256_truncated(data.lower().encode("ascii"), 2) != checksum:
+                        print("line checksum did not match, try same line again")
                         continue
                     try:
                         lines = int(id_lines)
                     except ValueError:
-                        print('internal error while parsing length')
+                        print("internal error while parsing length")
 
                     break
 
                 if repoid != id_repoid:
                     raise RepoIdMismatch()
 
-                result = b''
+                result = b""
                 idx = 1
                 # body line input
                 while True:
-                    inline = input(f'{idx:2d}: ')
-                    inline = inline.replace(' ', '')
-                    if inline == '':
-                        if yes('Abort import? [yN]:'):
+                    inline = input(f"{idx:2d}: ")
+                    inline = inline.replace(" ", "")
+                    if inline == "":
+                        if yes("Abort import? [yN]:"):
                             raise EOFError()
                     try:
-                        (data, checksum) = inline.split('-')
+                        (data, checksum) = inline.split("-")
                     except ValueError:
                         print("each line must contain exactly one '-', try again")
                         continue
@@ -208,8 +210,8 @@ class KeyManager:
                     except binascii.Error:
                         print("only characters 0-9 and a-f and '-' are valid, try again")
                         continue
-                    if sha256_truncated(idx.to_bytes(2, byteorder='big') + part, 2) != checksum:
-                        print(f'line checksum did not match, try line {idx} again')
+                    if sha256_truncated(idx.to_bytes(2, byteorder="big") + part, 2) != checksum:
+                        print(f"line checksum did not match, try line {idx} again")
                         continue
                     result += part
                     if idx == lines:
@@ -217,13 +219,13 @@ class KeyManager:
                     idx += 1
 
                 if sha256_truncated(result, 12) != id_complete_checksum:
-                    print('The overall checksum did not match, retry or enter a blank line to abort.')
+                    print("The overall checksum did not match, retry or enter a blank line to abort.")
                     continue
 
-                self.keyblob = '\n'.join(textwrap.wrap(b2a_base64(result).decode('ascii'))) + '\n'
+                self.keyblob = "\n".join(textwrap.wrap(b2a_base64(result).decode("ascii"))) + "\n"
                 self.store_keyblob(args)
                 break
 
         except EOFError:
-            print('\n - aborted')
+            print("\n - aborted")
             return
diff --git a/src/borg/crypto/nonces.py b/src/borg/crypto/nonces.py
index 12a597484..d1a9d9fbd 100644
--- a/src/borg/crypto/nonces.py
+++ b/src/borg/crypto/nonces.py
@@ -18,7 +18,7 @@ class NonceManager:
         self.repository = repository
         self.end_of_nonce_reservation = None
         self.manifest_nonce = manifest_nonce
-        self.nonce_file = os.path.join(get_security_dir(self.repository.id_str), 'nonce')
+        self.nonce_file = os.path.join(get_security_dir(self.repository.id_str), "nonce")
 
     def get_local_free_nonce(self):
         try:
@@ -78,7 +78,11 @@ class NonceManager:
 
         repo_free_nonce = self.get_repo_free_nonce()
         local_free_nonce = self.get_local_free_nonce()
-        free_nonce_space = max(x for x in (repo_free_nonce, local_free_nonce, self.manifest_nonce, self.end_of_nonce_reservation) if x is not None)
+        free_nonce_space = max(
+            x
+            for x in (repo_free_nonce, local_free_nonce, self.manifest_nonce, self.end_of_nonce_reservation)
+            if x is not None
+        )
         reservation_end = free_nonce_space + nonce_space_needed + NONCE_SPACE_RESERVATION
         assert reservation_end < MAX_REPRESENTABLE_NONCE
         self.commit_repo_nonce_reservation(reservation_end, repo_free_nonce)
diff --git a/src/borg/fuse.py b/src/borg/fuse.py
index b6349da7d..9caafd73b 100644
--- a/src/borg/fuse.py
+++ b/src/borg/fuse.py
@@ -20,7 +20,9 @@ if has_pyfuse3:
         @functools.wraps(fn)
         async def wrapper(*args, **kwargs):
             return fn(*args, **kwargs)
+
         return wrapper
+
 else:
     trio = None
 
@@ -29,6 +31,7 @@ else:
 
 
 from .logger import create_logger
+
 logger = create_logger()
 
 from .crypto.low_level import blake2b_128
@@ -79,7 +82,7 @@ class ItemCache:
     # to resize it in the first place; that's free).
     GROW_META_BY = 2 * 1024 * 1024
 
-    indirect_entry_struct = struct.Struct('=cII')
+    indirect_entry_struct = struct.Struct("=cII")
     assert indirect_entry_struct.size == 9
 
     def __init__(self, decrypted_repository):
@@ -105,7 +108,7 @@ class ItemCache:
         # These are items that span more than one chunk and thus cannot be efficiently cached
         # by the object cache (self.decrypted_repository), which would require variable-length structures;
         # possible but not worth the effort, see iter_archive_items.
-        self.fd = tempfile.TemporaryFile(prefix='borg-tmp')
+        self.fd = tempfile.TemporaryFile(prefix="borg-tmp")
 
         # A small LRU cache for chunks requested by ItemCache.get() from the object cache,
         # this significantly speeds up directory traversal and similar operations which
@@ -123,12 +126,12 @@ class ItemCache:
     def get(self, inode):
         offset = inode - self.offset
         if offset < 0:
-            raise ValueError('ItemCache.get() called with an invalid inode number')
-        if self.meta[offset] == ord(b'I'):
+            raise ValueError("ItemCache.get() called with an invalid inode number")
+        if self.meta[offset] == ord(b"I"):
             _, chunk_id_relative_offset, chunk_offset = self.indirect_entry_struct.unpack_from(self.meta, offset)
             chunk_id_offset = offset - chunk_id_relative_offset
             # bytearray slices are bytearrays as well, explicitly convert to bytes()
-            chunk_id = bytes(self.meta[chunk_id_offset:chunk_id_offset + 32])
+            chunk_id = bytes(self.meta[chunk_id_offset : chunk_id_offset + 32])
             chunk = self.chunks.get(chunk_id)
             if not chunk:
                 csize, chunk = next(self.decrypted_repository.get_many([chunk_id]))
@@ -137,12 +140,12 @@ class ItemCache:
             unpacker = msgpack.Unpacker()
             unpacker.feed(data)
             return Item(internal_dict=next(unpacker))
-        elif self.meta[offset] == ord(b'S'):
-            fd_offset = int.from_bytes(self.meta[offset + 1:offset + 9], 'little')
+        elif self.meta[offset] == ord(b"S"):
+            fd_offset = int.from_bytes(self.meta[offset + 1 : offset + 9], "little")
             self.fd.seek(fd_offset, io.SEEK_SET)
             return Item(internal_dict=next(msgpack.Unpacker(self.fd, read_size=1024)))
         else:
-            raise ValueError('Invalid entry type in self.meta')
+            raise ValueError("Invalid entry type in self.meta")
 
     def iter_archive_items(self, archive_item_ids, filter=None, consider_part_files=False):
         unpacker = msgpack.Unpacker()
@@ -153,7 +156,7 @@ class ItemCache:
         chunk_begin = 0
         # Length of the chunk preceding the current chunk
         last_chunk_length = 0
-        msgpacked_bytes = b''
+        msgpacked_bytes = b""
 
         write_offset = self.write_offset
         meta = self.meta
@@ -163,7 +166,7 @@ class ItemCache:
             # Store the chunk ID in the meta-array
             if write_offset + 32 >= len(meta):
                 self.meta = meta = meta + bytes(self.GROW_META_BY)
-            meta[write_offset:write_offset + 32] = key
+            meta[write_offset : write_offset + 32] = key
             current_id_offset = write_offset
             write_offset += 32
 
@@ -182,7 +185,7 @@ class ItemCache:
                 # tell() is not helpful for the need_more_data case, but we know it is the remainder
                 # of the data in that case. in the other case, tell() works as expected.
                 length = (len(data) - start) if need_more_data else (unpacker.tell() - stream_offset)
-                msgpacked_bytes += data[start:start+length]
+                msgpacked_bytes += data[start : start + length]
                 stream_offset += length
 
                 if need_more_data:
@@ -190,14 +193,14 @@ class ItemCache:
                     break
 
                 item = Item(internal_dict=item)
-                if filter and not filter(item) or not consider_part_files and 'part' in item:
-                    msgpacked_bytes = b''
+                if filter and not filter(item) or not consider_part_files and "part" in item:
+                    msgpacked_bytes = b""
                     continue
 
                 current_item = msgpacked_bytes
                 current_item_length = len(current_item)
                 current_spans_chunks = stream_offset - current_item_length < chunk_begin
-                msgpacked_bytes = b''
+                msgpacked_bytes = b""
 
                 if write_offset + 9 >= len(meta):
                     self.meta = meta = meta + bytes(self.GROW_META_BY)
@@ -221,11 +224,11 @@ class ItemCache:
                 if current_spans_chunks:
                     pos = self.fd.seek(0, io.SEEK_END)
                     self.fd.write(current_item)
-                    meta[write_offset:write_offset + 9] = b'S' + pos.to_bytes(8, 'little')
+                    meta[write_offset : write_offset + 9] = b"S" + pos.to_bytes(8, "little")
                     self.direct_items += 1
                 else:
                     item_offset = stream_offset - current_item_length - chunk_begin
-                    pack_indirect_into(meta, write_offset, b'I', write_offset - current_id_offset, item_offset)
+                    pack_indirect_into(meta, write_offset, b"I", write_offset - current_id_offset, item_offset)
                     self.indirect_items += 1
                 inode = write_offset + self.offset
                 write_offset += 9
@@ -236,8 +239,7 @@ class ItemCache:
 
 
 class FuseBackend:
-    """Virtual filesystem based on archive(s) to provide information to fuse
-    """
+    """Virtual filesystem based on archive(s) to provide information to fuse"""
 
     def __init__(self, key, manifest, repository, args, decrypted_repository):
         self.repository_uncached = repository
@@ -307,8 +309,7 @@ class FuseBackend:
         return self.inode_count
 
     def _create_dir(self, parent, mtime=None):
-        """Create directory
-        """
+        """Create directory"""
         ino = self._allocate_inode()
         if mtime is not None:
             self._items[ino] = Item(internal_dict=self.default_dir.as_dict())
@@ -319,26 +320,31 @@ class FuseBackend:
         return ino
 
     def find_inode(self, path, prefix=[]):
-        segments = prefix + path.split(b'/')
+        segments = prefix + path.split(b"/")
         inode = 1
         for segment in segments:
             inode = self.contents[inode][segment]
         return inode
 
     def _process_archive(self, archive_name, prefix=[]):
-        """Build FUSE inode hierarchy from archive metadata
-        """
+        """Build FUSE inode hierarchy from archive metadata"""
         self.file_versions = {}  # for versions mode: original path -> version
         t0 = time.perf_counter()
-        archive = Archive(self.repository_uncached, self.key, self._manifest, archive_name,
-                          consider_part_files=self._args.consider_part_files)
+        archive = Archive(
+            self.repository_uncached,
+            self.key,
+            self._manifest,
+            archive_name,
+            consider_part_files=self._args.consider_part_files,
+        )
         strip_components = self._args.strip_components
         matcher = Archiver.build_matcher(self._args.patterns, self._args.paths)
         hlm = HardLinkManager(id_type=bytes, info_type=str)  # hlid -> path
 
         filter = Archiver.build_filter(matcher, strip_components)
-        for item_inode, item in self.cache.iter_archive_items(archive.metadata.items, filter=filter,
-                                                              consider_part_files=self._args.consider_part_files):
+        for item_inode, item in self.cache.iter_archive_items(
+            archive.metadata.items, filter=filter, consider_part_files=self._args.consider_part_files
+        ):
             if strip_components:
                 item.path = os.sep.join(item.path.split(os.sep)[strip_components:])
             path = os.fsencode(item.path)
@@ -354,24 +360,24 @@ class FuseBackend:
                 else:
                     self._items[inode] = item
                     continue
-            segments = prefix + path.split(b'/')
+            segments = prefix + path.split(b"/")
             parent = 1
             for segment in segments[:-1]:
                 parent = self._process_inner(segment, parent)
             self._process_leaf(segments[-1], item, parent, prefix, is_dir, item_inode, hlm)
         duration = time.perf_counter() - t0
-        logger.debug('fuse: _process_archive completed in %.1f s for archive %s', duration, archive.name)
+        logger.debug("fuse: _process_archive completed in %.1f s for archive %s", duration, archive.name)
 
     def _process_leaf(self, name, item, parent, prefix, is_dir, item_inode, hlm):
         path = item.path
         del item.path  # save some space
 
         def file_version(item, path):
-            if 'chunks' in item:
+            if "chunks" in item:
                 file_id = blake2b_128(path)
                 current_version, previous_id = self.versions_index.get(file_id, (0, None))
 
-                contents_id = blake2b_128(b''.join(chunk_id for chunk_id, _ in item.chunks))
+                contents_id = blake2b_128(b"".join(chunk_id for chunk_id, _ in item.chunks))
 
                 if contents_id != previous_id:
                     current_version += 1
@@ -382,14 +388,14 @@ class FuseBackend:
         def make_versioned_name(name, version, add_dir=False):
             if add_dir:
                 # add intermediate directory with same name as filename
-                path_fname = name.rsplit(b'/', 1)
-                name += b'/' + path_fname[-1]
+                path_fname = name.rsplit(b"/", 1)
+                name += b"/" + path_fname[-1]
             # keep original extension at end to avoid confusing tools
             name, ext = os.path.splitext(name)
-            version_enc = os.fsencode('.%05d' % version)
+            version_enc = os.fsencode(".%05d" % version)
             return name + version_enc + ext
 
-        if 'hlid' in item:
+        if "hlid" in item:
             link_target = hlm.retrieve(id=item.hlid, default=None)
             if link_target is not None:
                 # Hard link was extracted previously, just link
@@ -401,10 +407,10 @@ class FuseBackend:
                 try:
                     inode = self.find_inode(link_target, prefix)
                 except KeyError:
-                    logger.warning('Skipping broken hard link: %s -> %s', path, link_target)
+                    logger.warning("Skipping broken hard link: %s -> %s", path, link_target)
                     return
                 item = self.get_item(inode)
-                item.nlink = item.get('nlink', 1) + 1
+                item.nlink = item.get("nlink", 1) + 1
                 self._items[inode] = item
             else:
                 inode = item_inode
@@ -439,31 +445,41 @@ class FuseBackend:
 
 
 class FuseOperations(llfuse.Operations, FuseBackend):
-    """Export archive as a FUSE filesystem
-    """
+    """Export archive as a FUSE filesystem"""
 
     def __init__(self, key, repository, manifest, args, decrypted_repository):
         llfuse.Operations.__init__(self)
         FuseBackend.__init__(self, key, manifest, repository, args, decrypted_repository)
         self.decrypted_repository = decrypted_repository
-        data_cache_capacity = int(os.environ.get('BORG_MOUNT_DATA_CACHE_ENTRIES', os.cpu_count() or 1))
-        logger.debug('mount data cache capacity: %d chunks', data_cache_capacity)
+        data_cache_capacity = int(os.environ.get("BORG_MOUNT_DATA_CACHE_ENTRIES", os.cpu_count() or 1))
+        logger.debug("mount data cache capacity: %d chunks", data_cache_capacity)
         self.data_cache = LRUCache(capacity=data_cache_capacity, dispose=lambda _: None)
         self._last_pos = LRUCache(capacity=FILES, dispose=lambda _: None)
 
     def sig_info_handler(self, sig_no, stack):
-        logger.debug('fuse: %d synth inodes, %d edges (%s)',
-                     self.inode_count, len(self.parent),
-                     # getsizeof is the size of the dict itself; key and value are two small-ish integers,
-                     # which are shared due to code structure (this has been verified).
-                     format_file_size(sys.getsizeof(self.parent) + len(self.parent) * sys.getsizeof(self.inode_count)))
-        logger.debug('fuse: %d pending archives', len(self.pending_archives))
-        logger.debug('fuse: ItemCache %d entries (%d direct, %d indirect), meta-array size %s, direct items size %s',
-                     self.cache.direct_items + self.cache.indirect_items, self.cache.direct_items, self.cache.indirect_items,
-                     format_file_size(sys.getsizeof(self.cache.meta)),
-                     format_file_size(os.stat(self.cache.fd.fileno()).st_size))
-        logger.debug('fuse: data cache: %d/%d entries, %s', len(self.data_cache.items()), self.data_cache._capacity,
-                     format_file_size(sum(len(chunk) for key, chunk in self.data_cache.items())))
+        logger.debug(
+            "fuse: %d synth inodes, %d edges (%s)",
+            self.inode_count,
+            len(self.parent),
+            # getsizeof is the size of the dict itself; key and value are two small-ish integers,
+            # which are shared due to code structure (this has been verified).
+            format_file_size(sys.getsizeof(self.parent) + len(self.parent) * sys.getsizeof(self.inode_count)),
+        )
+        logger.debug("fuse: %d pending archives", len(self.pending_archives))
+        logger.debug(
+            "fuse: ItemCache %d entries (%d direct, %d indirect), meta-array size %s, direct items size %s",
+            self.cache.direct_items + self.cache.indirect_items,
+            self.cache.direct_items,
+            self.cache.indirect_items,
+            format_file_size(sys.getsizeof(self.cache.meta)),
+            format_file_size(os.stat(self.cache.fd.fileno()).st_size),
+        )
+        logger.debug(
+            "fuse: data cache: %d/%d entries, %s",
+            len(self.data_cache.items()),
+            self.data_cache._capacity,
+            format_file_size(sum(len(chunk) for key, chunk in self.data_cache.items())),
+        )
         self.decrypted_repository.log_instrumentation()
 
     def mount(self, mountpoint, mount_options, foreground=False):
@@ -475,25 +491,25 @@ class FuseOperations(llfuse.Operations, FuseBackend):
                 if option == key:
                     options.pop(idx)
                     return present
-                if option.startswith(key + '='):
+                if option.startswith(key + "="):
                     options.pop(idx)
-                    value = option.split('=', 1)[1]
+                    value = option.split("=", 1)[1]
                     if wanted_type is bool:
                         v = value.lower()
-                        if v in ('y', 'yes', 'true', '1'):
+                        if v in ("y", "yes", "true", "1"):
                             return True
-                        if v in ('n', 'no', 'false', '0'):
+                        if v in ("n", "no", "false", "0"):
                             return False
-                        raise ValueError('unsupported value in option: %s' % option)
+                        raise ValueError("unsupported value in option: %s" % option)
                     if wanted_type is int:
                         try:
                             return int(value, base=int_base)
                         except ValueError:
-                            raise ValueError('unsupported value in option: %s' % option) from None
+                            raise ValueError("unsupported value in option: %s" % option) from None
                     try:
                         return wanted_type(value)
                     except ValueError:
-                        raise ValueError('unsupported value in option: %s' % option) from None
+                        raise ValueError("unsupported value in option: %s" % option) from None
             else:
                 return not_present
 
@@ -502,20 +518,20 @@ class FuseOperations(llfuse.Operations, FuseBackend):
         # cause security issues if used with allow_other mount option.
         # When not using allow_other or allow_root, access is limited to the
         # mounting user anyway.
-        options = ['fsname=borgfs', 'ro', 'default_permissions']
+        options = ["fsname=borgfs", "ro", "default_permissions"]
         if mount_options:
-            options.extend(mount_options.split(','))
-        ignore_permissions = pop_option(options, 'ignore_permissions', True, False, bool)
+            options.extend(mount_options.split(","))
+        ignore_permissions = pop_option(options, "ignore_permissions", True, False, bool)
         if ignore_permissions:
             # in case users have a use-case that requires NOT giving "default_permissions",
             # this is enabled by the custom "ignore_permissions" mount option which just
             # removes "default_permissions" again:
-            pop_option(options, 'default_permissions', True, False, bool)
-        self.allow_damaged_files = pop_option(options, 'allow_damaged_files', True, False, bool)
-        self.versions = pop_option(options, 'versions', True, False, bool)
-        self.uid_forced = pop_option(options, 'uid', None, None, int)
-        self.gid_forced = pop_option(options, 'gid', None, None, int)
-        self.umask = pop_option(options, 'umask', 0, 0, int, int_base=8)  # umask is octal, e.g. 222 or 0222
+            pop_option(options, "default_permissions", True, False, bool)
+        self.allow_damaged_files = pop_option(options, "allow_damaged_files", True, False, bool)
+        self.versions = pop_option(options, "versions", True, False, bool)
+        self.uid_forced = pop_option(options, "uid", None, None, int)
+        self.gid_forced = pop_option(options, "gid", None, None, int)
+        self.umask = pop_option(options, "umask", 0, 0, int, int_base=8)  # umask is octal, e.g. 222 or 0222
         dir_uid = self.uid_forced if self.uid_forced is not None else self.default_uid
         dir_gid = self.gid_forced if self.gid_forced is not None else self.default_gid
         dir_user = uid2user(dir_uid)
@@ -523,8 +539,9 @@ class FuseOperations(llfuse.Operations, FuseBackend):
         assert isinstance(dir_user, str)
         assert isinstance(dir_group, str)
         dir_mode = 0o40755 & ~self.umask
-        self.default_dir = Item(mode=dir_mode, mtime=int(time.time() * 1e9),
-                                user=dir_user, group=dir_group, uid=dir_uid, gid=dir_gid)
+        self.default_dir = Item(
+            mode=dir_mode, mtime=int(time.time() * 1e9), user=dir_user, group=dir_group, uid=dir_uid, gid=dir_gid
+        )
         self._create_filesystem()
         llfuse.init(self, mountpoint, options)
         if not foreground:
@@ -533,7 +550,7 @@ class FuseOperations(llfuse.Operations, FuseBackend):
             else:
                 with daemonizing() as (old_id, new_id):
                     # local repo: the locking process' PID is changing, migrate it:
-                    logger.debug('fuse: mount local repo, going to background: migrating lock.')
+                    logger.debug("fuse: mount local repo, going to background: migrating lock.")
                     self.repository_uncached.migrate_lock(old_id, new_id)
 
         # If the file system crashes, we do not want to umount because in that
@@ -543,11 +560,10 @@ class FuseOperations(llfuse.Operations, FuseBackend):
         # mirror.
         umount = False
         try:
-            with signal_handler('SIGUSR1', self.sig_info_handler), \
-                 signal_handler('SIGINFO', self.sig_info_handler):
+            with signal_handler("SIGUSR1", self.sig_info_handler), signal_handler("SIGINFO", self.sig_info_handler):
                 signal = fuse_main()
             # no crash and no signal (or it's ^C and we're in the foreground) -> umount request
-            umount = (signal is None or (signal == SIGINT and foreground))
+            umount = signal is None or (signal == SIGINT and foreground)
         finally:
             llfuse.close(umount)
 
@@ -573,19 +589,24 @@ class FuseOperations(llfuse.Operations, FuseBackend):
         entry.entry_timeout = 300
         entry.attr_timeout = 300
         entry.st_mode = item.mode & ~self.umask
-        entry.st_nlink = item.get('nlink', 1)
-        entry.st_uid, entry.st_gid = get_item_uid_gid(item, numeric=self.numeric_ids,
-                                                      uid_default=self.default_uid, gid_default=self.default_gid,
-                                                      uid_forced=self.uid_forced, gid_forced=self.gid_forced)
-        entry.st_rdev = item.get('rdev', 0)
+        entry.st_nlink = item.get("nlink", 1)
+        entry.st_uid, entry.st_gid = get_item_uid_gid(
+            item,
+            numeric=self.numeric_ids,
+            uid_default=self.default_uid,
+            gid_default=self.default_gid,
+            uid_forced=self.uid_forced,
+            gid_forced=self.gid_forced,
+        )
+        entry.st_rdev = item.get("rdev", 0)
         entry.st_size = item.get_size()
         entry.st_blksize = 512
         entry.st_blocks = (entry.st_size + entry.st_blksize - 1) // entry.st_blksize
         # note: older archives only have mtime (not atime nor ctime)
         entry.st_mtime_ns = mtime_ns = item.mtime
-        entry.st_atime_ns = item.get('atime', mtime_ns)
-        entry.st_ctime_ns = item.get('ctime', mtime_ns)
-        entry.st_birthtime_ns = item.get('birthtime', mtime_ns)
+        entry.st_atime_ns = item.get("atime", mtime_ns)
+        entry.st_ctime_ns = item.get("ctime", mtime_ns)
+        entry.st_birthtime_ns = item.get("birthtime", mtime_ns)
         return entry
 
     @async_wrapper
@@ -595,22 +616,22 @@ class FuseOperations(llfuse.Operations, FuseBackend):
     @async_wrapper
     def listxattr(self, inode, ctx=None):
         item = self.get_item(inode)
-        return item.get('xattrs', {}).keys()
+        return item.get("xattrs", {}).keys()
 
     @async_wrapper
     def getxattr(self, inode, name, ctx=None):
         item = self.get_item(inode)
         try:
-            return item.get('xattrs', {})[name] or b''
+            return item.get("xattrs", {})[name] or b""
         except KeyError:
             raise llfuse.FUSEError(llfuse.ENOATTR) from None
 
     @async_wrapper
     def lookup(self, parent_inode, name, ctx=None):
         self.check_pending_archive(parent_inode)
-        if name == b'.':
+        if name == b".":
             inode = parent_inode
-        elif name == b'..':
+        elif name == b"..":
             inode = self.parent[parent_inode]
         else:
             inode = self.contents[parent_inode].get(name)
@@ -622,12 +643,14 @@ class FuseOperations(llfuse.Operations, FuseBackend):
     def open(self, inode, flags, ctx=None):
         if not self.allow_damaged_files:
             item = self.get_item(inode)
-            if 'chunks_healthy' in item:
+            if "chunks_healthy" in item:
                 # Processed archive items don't carry the path anymore; for converting the inode
                 # to the path we'd either have to store the inverse of the current structure,
                 # or search the entire archive. So we just don't print it. It's easy to correlate anyway.
-                logger.warning('File has damaged (all-zero) chunks. Try running borg check --repair. '
-                               'Mount with allow_damaged_files to read damaged files.')
+                logger.warning(
+                    "File has damaged (all-zero) chunks. Try running borg check --repair. "
+                    "Mount with allow_damaged_files to read damaged files."
+                )
                 raise llfuse.FUSEError(errno.EIO)
         return llfuse.FileInfo(fh=inode) if has_pyfuse3 else inode
 
@@ -669,7 +692,7 @@ class FuseOperations(llfuse.Operations, FuseBackend):
                 if offset + n < len(data):
                     # chunk was only partially read, cache it
                     self.data_cache[id] = data
-            parts.append(data[offset:offset + n])
+            parts.append(data[offset : offset + n])
             offset = 0
             size -= n
             if not size:
@@ -678,12 +701,13 @@ class FuseOperations(llfuse.Operations, FuseBackend):
                 else:
                     self._last_pos[fh] = (chunk_no, chunk_offset)
                 break
-        return b''.join(parts)
+        return b"".join(parts)
 
     # note: we can't have a generator (with yield) and not a generator (async) in the same method
     if has_pyfuse3:
+
         async def readdir(self, fh, off, token):
-            entries = [(b'.', fh), (b'..', self.parent[fh])]
+            entries = [(b".", fh), (b"..", self.parent[fh])]
             entries.extend(self.contents[fh].items())
             for i, (name, inode) in enumerate(entries[off:], off):
                 attrs = self._getattr(inode)
@@ -691,8 +715,9 @@ class FuseOperations(llfuse.Operations, FuseBackend):
                     break
 
     else:
+
         def readdir(self, fh, off):
-            entries = [(b'.', fh), (b'..', self.parent[fh])]
+            entries = [(b".", fh), (b"..", self.parent[fh])]
             entries.extend(self.contents[fh].items())
             for i, (name, inode) in enumerate(entries[off:], off):
                 attrs = self._getattr(inode)
diff --git a/src/borg/fuse_impl.py b/src/borg/fuse_impl.py
index 390ac576f..b63d95794 100644
--- a/src/borg/fuse_impl.py
+++ b/src/borg/fuse_impl.py
@@ -4,11 +4,11 @@ load library for lowlevel FUSE implementation
 
 import os
 
-BORG_FUSE_IMPL = os.environ.get('BORG_FUSE_IMPL', 'pyfuse3,llfuse')
+BORG_FUSE_IMPL = os.environ.get("BORG_FUSE_IMPL", "pyfuse3,llfuse")
 
-for FUSE_IMPL in BORG_FUSE_IMPL.split(','):
+for FUSE_IMPL in BORG_FUSE_IMPL.split(","):
     FUSE_IMPL = FUSE_IMPL.strip()
-    if FUSE_IMPL == 'pyfuse3':
+    if FUSE_IMPL == "pyfuse3":
         try:
             import pyfuse3 as llfuse
         except ImportError:
@@ -17,7 +17,7 @@ for FUSE_IMPL in BORG_FUSE_IMPL.split(','):
             has_llfuse = False
             has_pyfuse3 = True
             break
-    elif FUSE_IMPL == 'llfuse':
+    elif FUSE_IMPL == "llfuse":
         try:
             import llfuse
         except ImportError:
@@ -26,7 +26,7 @@ for FUSE_IMPL in BORG_FUSE_IMPL.split(','):
             has_llfuse = True
             has_pyfuse3 = False
             break
-    elif FUSE_IMPL == 'none':
+    elif FUSE_IMPL == "none":
         pass
     else:
         raise RuntimeError("unknown fuse implementation in BORG_FUSE_IMPL: '%s'" % BORG_FUSE_IMPL)
diff --git a/src/borg/helpers/__init__.py b/src/borg/helpers/__init__.py
index d8a4cda62..67ee948e0 100644
--- a/src/borg/helpers/__init__.py
+++ b/src/borg/helpers/__init__.py
@@ -24,7 +24,7 @@ from . import msgpack
 # generic mechanism to enable users to invoke workarounds by setting the
 # BORG_WORKAROUNDS environment variable to a list of comma-separated strings.
 # see the docs for a list of known workaround strings.
-workarounds = tuple(os.environ.get('BORG_WORKAROUNDS', '').split(','))
+workarounds = tuple(os.environ.get("BORG_WORKAROUNDS", "").split(","))
 
 """
 The global exit_code variable is used so that modules other than archiver can increase the program exit code if a
diff --git a/src/borg/helpers/checks.py b/src/borg/helpers/checks.py
index 26a6c0129..74b50a03f 100644
--- a/src/borg/helpers/checks.py
+++ b/src/borg/helpers/checks.py
@@ -23,15 +23,16 @@ class ExtensionModuleError(Error):
 
 def check_extension_modules():
     from .. import platform, compress, crypto, item, chunker, hashindex
-    if hashindex.API_VERSION != '1.2_01':
+
+    if hashindex.API_VERSION != "1.2_01":
         raise ExtensionModuleError
-    if chunker.API_VERSION != '1.2_01':
+    if chunker.API_VERSION != "1.2_01":
         raise ExtensionModuleError
-    if compress.API_VERSION != '1.2_02':
+    if compress.API_VERSION != "1.2_02":
         raise ExtensionModuleError
-    if crypto.low_level.API_VERSION != '1.3_01':
+    if crypto.low_level.API_VERSION != "1.3_01":
         raise ExtensionModuleError
-    if item.API_VERSION != '1.2_01':
+    if item.API_VERSION != "1.2_01":
         raise ExtensionModuleError
-    if platform.API_VERSION != platform.OS_API_VERSION or platform.API_VERSION != '1.2_05':
+    if platform.API_VERSION != platform.OS_API_VERSION or platform.API_VERSION != "1.2_05":
         raise ExtensionModuleError
diff --git a/src/borg/helpers/datastruct.py b/src/borg/helpers/datastruct.py
index 31192a8c7..f647beb14 100644
--- a/src/borg/helpers/datastruct.py
+++ b/src/borg/helpers/datastruct.py
@@ -3,6 +3,7 @@ from .errors import Error
 
 class StableDict(dict):
     """A dict subclass with stable items() ordering"""
+
     def items(self):
         return sorted(super().items())
 
@@ -20,8 +21,8 @@ class Buffer:
         Initialize the buffer: use allocator(size) call to allocate a buffer.
         Optionally, set the upper <limit> for the buffer size.
         """
-        assert callable(allocator), 'must give alloc(size) function as first param'
-        assert limit is None or size <= limit, 'initial size must be <= limit'
+        assert callable(allocator), "must give alloc(size) function as first param"
+        assert limit is None or size <= limit, "initial size must be <= limit"
         self.allocator = allocator
         self.limit = limit
         self.resize(size, init=True)
diff --git a/src/borg/helpers/errors.py b/src/borg/helpers/errors.py
index f07f7bb98..ae71cc565 100644
--- a/src/borg/helpers/errors.py
+++ b/src/borg/helpers/errors.py
@@ -5,6 +5,7 @@ from ..crypto.low_level import IntegrityError as IntegrityErrorBase
 
 class Error(Exception):
     """Error: {}"""
+
     # Error base class
 
     # if we raise such an Error and it is only caught by the uppermost
@@ -26,6 +27,7 @@ class Error(Exception):
 
 class ErrorWithTraceback(Error):
     """Error: {}"""
+
     # like Error, but show a traceback also
     traceback = True
 
diff --git a/src/borg/helpers/fs.py b/src/borg/helpers/fs.py
index 9d3c55c5e..c12e7a7d3 100644
--- a/src/borg/helpers/fs.py
+++ b/src/borg/helpers/fs.py
@@ -16,6 +16,7 @@ from ..platformflags import is_win32
 from ..constants import *  # NOQA
 
 from ..logger import create_logger
+
 logger = create_logger()
 
 
@@ -50,32 +51,32 @@ def get_base_dir():
     - ~$USER, if USER is set
     - ~
     """
-    base_dir = os.environ.get('BORG_BASE_DIR') or os.environ.get('HOME')
+    base_dir = os.environ.get("BORG_BASE_DIR") or os.environ.get("HOME")
     # os.path.expanduser() behaves differently for '~' and '~someuser' as
     # parameters: when called with an explicit username, the possibly set
     # environment variable HOME is no longer respected. So we have to check if
     # it is set and only expand the user's home directory if HOME is unset.
     if not base_dir:
-        base_dir = os.path.expanduser('~%s' % os.environ.get('USER', ''))
+        base_dir = os.path.expanduser("~%s" % os.environ.get("USER", ""))
     return base_dir
 
 
 def get_keys_dir():
     """Determine where to repository keys and cache"""
-    keys_dir = os.environ.get('BORG_KEYS_DIR')
+    keys_dir = os.environ.get("BORG_KEYS_DIR")
     if keys_dir is None:
         # note: do not just give this as default to the environment.get(), see issue #5979.
-        keys_dir = os.path.join(get_config_dir(), 'keys')
+        keys_dir = os.path.join(get_config_dir(), "keys")
     ensure_dir(keys_dir)
     return keys_dir
 
 
 def get_security_dir(repository_id=None):
     """Determine where to store local security information."""
-    security_dir = os.environ.get('BORG_SECURITY_DIR')
+    security_dir = os.environ.get("BORG_SECURITY_DIR")
     if security_dir is None:
         # note: do not just give this as default to the environment.get(), see issue #5979.
-        security_dir = os.path.join(get_config_dir(), 'security')
+        security_dir = os.path.join(get_config_dir(), "security")
     if repository_id:
         security_dir = os.path.join(security_dir, repository_id)
     ensure_dir(security_dir)
@@ -85,22 +86,28 @@ def get_security_dir(repository_id=None):
 def get_cache_dir():
     """Determine where to repository keys and cache"""
     # Get cache home path
-    cache_home = os.path.join(get_base_dir(), '.cache')
+    cache_home = os.path.join(get_base_dir(), ".cache")
     # Try to use XDG_CACHE_HOME instead if BORG_BASE_DIR isn't explicitly set
-    if not os.environ.get('BORG_BASE_DIR'):
-        cache_home = os.environ.get('XDG_CACHE_HOME', cache_home)
+    if not os.environ.get("BORG_BASE_DIR"):
+        cache_home = os.environ.get("XDG_CACHE_HOME", cache_home)
     # Use BORG_CACHE_DIR if set, otherwise assemble final path from cache home path
-    cache_dir = os.environ.get('BORG_CACHE_DIR', os.path.join(cache_home, 'borg'))
+    cache_dir = os.environ.get("BORG_CACHE_DIR", os.path.join(cache_home, "borg"))
     # Create path if it doesn't exist yet
     ensure_dir(cache_dir)
     cache_tag_fn = os.path.join(cache_dir, CACHE_TAG_NAME)
     if not os.path.exists(cache_tag_fn):
-        cache_tag_contents = CACHE_TAG_CONTENTS + textwrap.dedent("""
+        cache_tag_contents = (
+            CACHE_TAG_CONTENTS
+            + textwrap.dedent(
+                """
         # This file is a cache directory tag created by Borg.
         # For information about cache directory tags, see:
         #       http://www.bford.info/cachedir/spec.html
-        """).encode('ascii')
+        """
+            ).encode("ascii")
+        )
         from ..platform import SaveFile
+
         with SaveFile(cache_tag_fn, binary=True) as fd:
             fd.write(cache_tag_contents)
     return cache_dir
@@ -109,12 +116,12 @@ def get_cache_dir():
 def get_config_dir():
     """Determine where to store whole config"""
     # Get config home path
-    config_home = os.path.join(get_base_dir(), '.config')
+    config_home = os.path.join(get_base_dir(), ".config")
     # Try to use XDG_CONFIG_HOME instead if BORG_BASE_DIR isn't explicitly set
-    if not os.environ.get('BORG_BASE_DIR'):
-        config_home = os.environ.get('XDG_CONFIG_HOME', config_home)
+    if not os.environ.get("BORG_BASE_DIR"):
+        config_home = os.environ.get("XDG_CONFIG_HOME", config_home)
     # Use BORG_CONFIG_DIR if set, otherwise assemble final path from config home path
-    config_dir = os.environ.get('BORG_CONFIG_DIR', os.path.join(config_home, 'borg'))
+    config_dir = os.environ.get("BORG_CONFIG_DIR", os.path.join(config_home, "borg"))
     # Create path if it doesn't exist yet
     ensure_dir(config_dir)
     return config_dir
@@ -130,7 +137,7 @@ def dir_is_cachedir(path):
     tag_path = os.path.join(path, CACHE_TAG_NAME)
     try:
         if os.path.exists(tag_path):
-            with open(tag_path, 'rb') as tag_file:
+            with open(tag_path, "rb") as tag_file:
                 tag_data = tag_file.read(len(CACHE_TAG_CONTENTS))
                 if tag_data == CACHE_TAG_CONTENTS:
                     return True
@@ -157,13 +164,12 @@ def dir_is_tagged(path, exclude_caches, exclude_if_present):
     return tag_names
 
 
-_safe_re = re.compile(r'^((\.\.)?/+)+')
+_safe_re = re.compile(r"^((\.\.)?/+)+")
 
 
 def make_path_safe(path):
-    """Make path safe by making it relative and local
-    """
-    return _safe_re.sub('', path) or '.'
+    """Make path safe by making it relative and local"""
+    return _safe_re.sub("", path) or "."
 
 
 class HardLinkManager:
@@ -189,6 +195,7 @@ class HardLinkManager:
        For better hardlink support (including the very first hardlink item for each group of same-target hardlinks),
        we would need a 2-pass processing, which is not yet implemented.
     """
+
     def __init__(self, *, id_type, info_type):
         self._map = {}
         self.id_type = id_type
@@ -198,21 +205,21 @@ class HardLinkManager:
         return stat.S_ISREG(mode) or stat.S_ISBLK(mode) or stat.S_ISCHR(mode) or stat.S_ISFIFO(mode)
 
     def borg1_hardlink_master(self, item):  # legacy
-        return item.get('hardlink_master', True) and 'source' not in item and self.borg1_hardlinkable(item.mode)
+        return item.get("hardlink_master", True) and "source" not in item and self.borg1_hardlinkable(item.mode)
 
     def borg1_hardlink_slave(self, item):  # legacy
-        return 'source' in item and self.borg1_hardlinkable(item.mode)
+        return "source" in item and self.borg1_hardlinkable(item.mode)
 
     def hardlink_id_from_path(self, path):
         """compute a hardlink id from a path"""
         assert isinstance(path, str)
-        return hashlib.sha256(path.encode('utf-8', errors='surrogateescape')).digest()
+        return hashlib.sha256(path.encode("utf-8", errors="surrogateescape")).digest()
 
     def hardlink_id_from_inode(self, *, ino, dev):
         """compute a hardlink id from an inode"""
         assert isinstance(ino, int)
         assert isinstance(dev, int)
-        return hashlib.sha256(f'{ino}/{dev}'.encode()).digest()
+        return hashlib.sha256(f"{ino}/{dev}".encode()).digest()
 
     def remember(self, *, id, info):
         """
@@ -243,7 +250,7 @@ def scandir_keyfunc(dirent):
         return (0, dirent.inode())
     except OSError as e:
         # maybe a permission denied error while doing a stat() on the dirent
-        logger.debug('scandir_inorder: Unable to stat %s: %s', dirent.path, e)
+        logger.debug("scandir_inorder: Unable to stat %s: %s", dirent.path, e)
         # order this dirent after all the others lexically by file name
         # we may not break the whole scandir just because of an exception in one dirent
         # ignore the exception for now, since another stat will be done later anyways
@@ -268,7 +275,7 @@ def secure_erase(path, *, avoid_collateral_damage):
     If avoid_collateral_damage is False, we always secure erase.
     If there are hardlinks pointing to the same inode as <path>, they will contain random garbage afterwards.
     """
-    with open(path, 'r+b') as fd:
+    with open(path, "r+b") as fd:
         st = os.stat(fd.fileno())
         if not (st.st_nlink > 1 and avoid_collateral_damage):
             fd.write(os.urandom(st.st_size))
@@ -303,7 +310,7 @@ def safe_unlink(path):
         # no other hardlink! try to recover free space by truncating this file.
         try:
             # Do not create *path* if it does not exist, open for truncation in r+b mode (=O_RDWR|O_BINARY).
-            with open(path, 'r+b') as fd:
+            with open(path, "r+b") as fd:
                 fd.truncate()
         except OSError:
             # truncate didn't work, so we still have the original unlink issue - give up:
@@ -314,10 +321,10 @@ def safe_unlink(path):
 
 
 def dash_open(path, mode):
-    assert '+' not in mode  # the streams are either r or w, but never both
-    if path == '-':
-        stream = sys.stdin if 'r' in mode else sys.stdout
-        return stream.buffer if 'b' in mode else stream
+    assert "+" not in mode  # the streams are either r or w, but never both
+    if path == "-":
+        stream = sys.stdin if "r" in mode else sys.stdout
+        return stream.buffer if "b" in mode else stream
     else:
         return open(path, mode)
 
@@ -325,17 +332,17 @@ def dash_open(path, mode):
 def O_(*flags):
     result = 0
     for flag in flags:
-        result |= getattr(os, 'O_' + flag, 0)
+        result |= getattr(os, "O_" + flag, 0)
     return result
 
 
-flags_base = O_('BINARY', 'NOCTTY', 'RDONLY')
-flags_special = flags_base | O_('NOFOLLOW')  # BLOCK == wait when reading devices or fifos
+flags_base = O_("BINARY", "NOCTTY", "RDONLY")
+flags_special = flags_base | O_("NOFOLLOW")  # BLOCK == wait when reading devices or fifos
 flags_special_follow = flags_base  # BLOCK == wait when reading symlinked devices or fifos
-flags_normal = flags_base | O_('NONBLOCK', 'NOFOLLOW')
-flags_noatime = flags_normal | O_('NOATIME')
-flags_root = O_('RDONLY')
-flags_dir = O_('DIRECTORY', 'RDONLY', 'NOFOLLOW')
+flags_normal = flags_base | O_("NONBLOCK", "NOFOLLOW")
+flags_noatime = flags_normal | O_("NOATIME")
+flags_root = O_("RDONLY")
+flags_dir = O_("DIRECTORY", "RDONLY", "NOFOLLOW")
 
 
 def os_open(*, flags, path=None, parent_fd=None, name=None, noatime=False):
@@ -362,7 +369,7 @@ def os_open(*, flags, path=None, parent_fd=None, name=None, noatime=False):
         return None
     _flags_normal = flags
     if noatime:
-        _flags_noatime = _flags_normal | O_('NOATIME')
+        _flags_noatime = _flags_normal | O_("NOATIME")
         try:
             # if we have O_NOATIME, this likely will succeed if we are root or owner of file:
             fd = os.open(fname, _flags_noatime, dir_fd=parent_fd)
@@ -375,7 +382,8 @@ def os_open(*, flags, path=None, parent_fd=None, name=None, noatime=False):
         except OSError as exc:
             # O_NOATIME causes EROFS when accessing a volume shadow copy in WSL1
             from . import workarounds
-            if 'retry_erofs' in workarounds and exc.errno == errno.EROFS and _flags_noatime != _flags_normal:
+
+            if "retry_erofs" in workarounds and exc.errno == errno.EROFS and _flags_noatime != _flags_normal:
                 fd = os.open(fname, _flags_normal, dir_fd=parent_fd)
             else:
                 raise
@@ -407,6 +415,6 @@ def os_stat(*, path=None, parent_fd=None, name=None, follow_symlinks=False):
 def umount(mountpoint):
     env = prepare_subprocess_env(system=True)
     try:
-        return subprocess.call(['fusermount', '-u', mountpoint], env=env)
+        return subprocess.call(["fusermount", "-u", mountpoint], env=env)
     except FileNotFoundError:
-        return subprocess.call(['umount', mountpoint], env=env)
+        return subprocess.call(["umount", mountpoint], env=env)
diff --git a/src/borg/helpers/manifest.py b/src/borg/helpers/manifest.py
index f2eeaad68..1aeaf91fa 100644
--- a/src/borg/helpers/manifest.py
+++ b/src/borg/helpers/manifest.py
@@ -9,6 +9,7 @@ from operator import attrgetter
 from .errors import Error
 
 from ..logger import create_logger
+
 logger = create_logger()
 
 from .datastruct import StableDict
@@ -26,10 +27,10 @@ class MandatoryFeatureUnsupported(Error):
     """Unsupported repository feature(s) {}. A newer version of borg is required to access this repository."""
 
 
-ArchiveInfo = namedtuple('ArchiveInfo', 'name id ts')
+ArchiveInfo = namedtuple("ArchiveInfo", "name id ts")
 
-AI_HUMAN_SORT_KEYS = ['timestamp'] + list(ArchiveInfo._fields)
-AI_HUMAN_SORT_KEYS.remove('ts')
+AI_HUMAN_SORT_KEYS = ["timestamp"] + list(ArchiveInfo._fields)
+AI_HUMAN_SORT_KEYS.remove("ts")
 
 
 class Archives(abc.MutableMapping):
@@ -38,6 +39,7 @@ class Archives(abc.MutableMapping):
     and we can deal with str keys (and it internally encodes to byte keys) and either
     str timestamps or datetime timestamps.
     """
+
     def __init__(self):
         # key: str archive name, value: dict('id': bytes_id, 'time': str_iso_ts)
         self._archives = {}
@@ -53,8 +55,8 @@ class Archives(abc.MutableMapping):
         values = self._archives.get(name)
         if values is None:
             raise KeyError
-        ts = parse_timestamp(values['time'])
-        return ArchiveInfo(name=name, id=values['id'], ts=ts)
+        ts = parse_timestamp(values["time"])
+        return ArchiveInfo(name=name, id=values["id"], ts=ts)
 
     def __setitem__(self, name, info):
         assert isinstance(name, str)
@@ -64,13 +66,15 @@ class Archives(abc.MutableMapping):
         if isinstance(ts, datetime):
             ts = ts.replace(tzinfo=None).strftime(ISO_FORMAT)
         assert isinstance(ts, str)
-        self._archives[name] = {'id': id, 'time': ts}
+        self._archives[name] = {"id": id, "time": ts}
 
     def __delitem__(self, name):
         assert isinstance(name, str)
         del self._archives[name]
 
-    def list(self, *, glob=None, match_end=r'\Z', sort_by=(), consider_checkpoints=True, first=None, last=None, reverse=False):
+    def list(
+        self, *, glob=None, match_end=r"\Z", sort_by=(), consider_checkpoints=True, first=None, last=None, reverse=False
+    ):
         """
         Return list of ArchiveInfo instances according to the parameters.
 
@@ -84,17 +88,17 @@ class Archives(abc.MutableMapping):
               some callers EXPECT to iterate over all archives in a repo for correct operation.
         """
         if isinstance(sort_by, (str, bytes)):
-            raise TypeError('sort_by must be a sequence of str')
-        regex = re.compile(shellpattern.translate(glob or '*', match_end=match_end))
+            raise TypeError("sort_by must be a sequence of str")
+        regex = re.compile(shellpattern.translate(glob or "*", match_end=match_end))
         archives = [x for x in self.values() if regex.match(x.name) is not None]
         if not consider_checkpoints:
-            archives = [x for x in archives if '.checkpoint' not in x.name]
+            archives = [x for x in archives if ".checkpoint" not in x.name]
         for sortkey in reversed(sort_by):
             archives.sort(key=attrgetter(sortkey))
         if first:
             archives = archives[:first]
         elif last:
-            archives = archives[max(len(archives) - last, 0):]
+            archives = archives[max(len(archives) - last, 0) :]
         if reverse:
             archives.reverse()
         return archives
@@ -103,17 +107,25 @@ class Archives(abc.MutableMapping):
         """
         get a list of archives, considering --first/last/prefix/glob-archives/sort/consider-checkpoints cmdline args
         """
-        name = getattr(args, 'name', None)
-        consider_checkpoints = getattr(args, 'consider_checkpoints', None)
+        name = getattr(args, "name", None)
+        consider_checkpoints = getattr(args, "consider_checkpoints", None)
         if name is not None:
-            raise Error('Giving a specific name is incompatible with options --first, --last, -a / --glob-archives, and --consider-checkpoints.')
-        return self.list(sort_by=args.sort_by.split(','), consider_checkpoints=consider_checkpoints, glob=args.glob_archives, first=args.first, last=args.last)
+            raise Error(
+                "Giving a specific name is incompatible with options --first, --last, -a / --glob-archives, and --consider-checkpoints."
+            )
+        return self.list(
+            sort_by=args.sort_by.split(","),
+            consider_checkpoints=consider_checkpoints,
+            glob=args.glob_archives,
+            first=args.first,
+            last=args.last,
+        )
 
     def set_raw_dict(self, d):
         """set the dict we get from the msgpack unpacker"""
         for k, v in d.items():
             assert isinstance(k, str)
-            assert isinstance(v, dict) and 'id' in v and 'time' in v
+            assert isinstance(v, dict) and "id" in v and "time" in v
             self._archives[k] = v
 
     def get_raw_dict(self):
@@ -122,7 +134,6 @@ class Archives(abc.MutableMapping):
 
 
 class Manifest:
-
     @enum.unique
     class Operation(enum.Enum):
         # The comments here only roughly describe the scope of each feature. In the end, additions need to be
@@ -133,25 +144,25 @@ class Manifest:
 
         # The READ operation describes which features are needed to safely list and extract the archives in the
         # repository.
-        READ = 'read'
+        READ = "read"
         # The CHECK operation is for all operations that need either to understand every detail
         # of the repository (for consistency checks and repairs) or are seldom used functions that just
         # should use the most restrictive feature set because more fine grained compatibility tracking is
         # not needed.
-        CHECK = 'check'
+        CHECK = "check"
         # The WRITE operation is for adding archives. Features here ensure that older clients don't add archives
         # in an old format, or is used to lock out clients that for other reasons can no longer safely add new
         # archives.
-        WRITE = 'write'
+        WRITE = "write"
         # The DELETE operation is for all operations (like archive deletion) that need a 100% correct reference
         # count and the need to be able to find all (directly and indirectly) referenced chunks of a given archive.
-        DELETE = 'delete'
+        DELETE = "delete"
 
     NO_OPERATION_CHECK = tuple()
 
     SUPPORTED_REPO_FEATURES = frozenset([])
 
-    MANIFEST_ID = b'\0' * 32
+    MANIFEST_ID = b"\0" * 32
 
     def __init__(self, key, repository, item_keys=None):
         self.archives = Archives()
@@ -175,6 +186,7 @@ class Manifest:
         from ..item import ManifestItem
         from ..crypto.key import key_factory, tam_required_file, tam_required
         from ..repository import Repository
+
         try:
             cdata = repository.get(cls.MANIFEST_ID)
         except Repository.ObjectNotFound:
@@ -183,26 +195,28 @@ class Manifest:
             key = key_factory(repository, cdata)
         manifest = cls(key, repository)
         data = key.decrypt(cls.MANIFEST_ID, cdata)
-        manifest_dict, manifest.tam_verified = key.unpack_and_verify_manifest(data, force_tam_not_required=force_tam_not_required)
+        manifest_dict, manifest.tam_verified = key.unpack_and_verify_manifest(
+            data, force_tam_not_required=force_tam_not_required
+        )
         m = ManifestItem(internal_dict=manifest_dict)
         manifest.id = key.id_hash(data)
-        if m.get('version') not in (1, 2):
-            raise ValueError('Invalid manifest version')
+        if m.get("version") not in (1, 2):
+            raise ValueError("Invalid manifest version")
         manifest.archives.set_raw_dict(m.archives)
-        manifest.timestamp = m.get('timestamp')
+        manifest.timestamp = m.get("timestamp")
         manifest.config = m.config
         # valid item keys are whatever is known in the repo or every key we know
-        manifest.item_keys = ITEM_KEYS | frozenset(m.get('item_keys', []))
+        manifest.item_keys = ITEM_KEYS | frozenset(m.get("item_keys", []))
 
         if manifest.tam_verified:
-            manifest_required = manifest.config.get('tam_required', False)
+            manifest_required = manifest.config.get("tam_required", False)
             security_required = tam_required(repository)
             if manifest_required and not security_required:
-                logger.debug('Manifest is TAM verified and says TAM is required, updating security database...')
+                logger.debug("Manifest is TAM verified and says TAM is required, updating security database...")
                 file = tam_required_file(repository)
-                open(file, 'w').close()
+                open(file, "w").close()
             if not manifest_required and security_required:
-                logger.debug('Manifest is TAM verified and says TAM is *not* required, updating security database...')
+                logger.debug("Manifest is TAM verified and says TAM is *not* required, updating security database...")
                 os.unlink(tam_required_file(repository))
         manifest.check_repository_compatibility(operations)
         return manifest, key
@@ -210,32 +224,33 @@ class Manifest:
     def check_repository_compatibility(self, operations):
         for operation in operations:
             assert isinstance(operation, self.Operation)
-            feature_flags = self.config.get('feature_flags', None)
+            feature_flags = self.config.get("feature_flags", None)
             if feature_flags is None:
                 return
             if operation.value not in feature_flags:
                 continue
             requirements = feature_flags[operation.value]
-            if 'mandatory' in requirements:
-                unsupported = set(requirements['mandatory']) - self.SUPPORTED_REPO_FEATURES
+            if "mandatory" in requirements:
+                unsupported = set(requirements["mandatory"]) - self.SUPPORTED_REPO_FEATURES
                 if unsupported:
                     raise MandatoryFeatureUnsupported(list(unsupported))
 
     def get_all_mandatory_features(self):
         result = {}
-        feature_flags = self.config.get('feature_flags', None)
+        feature_flags = self.config.get("feature_flags", None)
         if feature_flags is None:
             return result
 
         for operation, requirements in feature_flags.items():
-            if 'mandatory' in requirements:
-                result[operation] = set(requirements['mandatory'])
+            if "mandatory" in requirements:
+                result[operation] = set(requirements["mandatory"])
         return result
 
     def write(self):
         from ..item import ManifestItem
+
         if self.key.tam_required:
-            self.config['tam_required'] = True
+            self.config["tam_required"] = True
         # self.timestamp needs to be strictly monotonically increasing. Clocks often are not set correctly
         if self.timestamp is None:
             self.timestamp = datetime.utcnow().strftime(ISO_FORMAT)
diff --git a/src/borg/helpers/misc.py b/src/borg/helpers/misc.py
index 96eb78993..ae40974db 100644
--- a/src/borg/helpers/misc.py
+++ b/src/borg/helpers/misc.py
@@ -10,6 +10,7 @@ from itertools import islice
 from operator import attrgetter
 
 from ..logger import create_logger
+
 logger = create_logger()
 
 from .time import to_localtime
@@ -30,15 +31,17 @@ def prune_within(archives, hours, kept_because):
     return result
 
 
-PRUNING_PATTERNS = OrderedDict([
-    ("secondly", '%Y-%m-%d %H:%M:%S'),
-    ("minutely", '%Y-%m-%d %H:%M'),
-    ("hourly", '%Y-%m-%d %H'),
-    ("daily", '%Y-%m-%d'),
-    ("weekly", '%G-%V'),
-    ("monthly", '%Y-%m'),
-    ("yearly", '%Y'),
-])
+PRUNING_PATTERNS = OrderedDict(
+    [
+        ("secondly", "%Y-%m-%d %H:%M:%S"),
+        ("minutely", "%Y-%m-%d %H:%M"),
+        ("hourly", "%Y-%m-%d %H"),
+        ("daily", "%Y-%m-%d"),
+        ("weekly", "%G-%V"),
+        ("monthly", "%Y-%m"),
+        ("yearly", "%Y"),
+    ]
+)
 
 
 def prune_split(archives, rule, n, kept_because=None):
@@ -51,7 +54,7 @@ def prune_split(archives, rule, n, kept_because=None):
         return keep
 
     a = None
-    for a in sorted(archives, key=attrgetter('ts'), reverse=True):
+    for a in sorted(archives, key=attrgetter("ts"), reverse=True):
         period = to_localtime(a.ts).strftime(pattern)
         if period != last:
             last = period
@@ -63,14 +66,14 @@ def prune_split(archives, rule, n, kept_because=None):
     # Keep oldest archive if we didn't reach the target retention count
     if a is not None and len(keep) < n and a.id not in kept_because:
         keep.append(a)
-        kept_because[a.id] = (rule+"[oldest]", len(keep))
+        kept_because[a.id] = (rule + "[oldest]", len(keep))
     return keep
 
 
 def sysinfo():
-    show_sysinfo = os.environ.get('BORG_SHOW_SYSINFO', 'yes').lower()
-    if show_sysinfo == 'no':
-        return ''
+    show_sysinfo = os.environ.get("BORG_SHOW_SYSINFO", "yes").lower()
+    if show_sysinfo == "no":
+        return ""
 
     python_implementation = platform.python_implementation()
     python_version = platform.python_version()
@@ -80,30 +83,34 @@ def sysinfo():
         uname = os.uname()
     except AttributeError:
         uname = None
-    if sys.platform.startswith('linux'):
-        linux_distribution = ('Unknown Linux', '', '')
+    if sys.platform.startswith("linux"):
+        linux_distribution = ("Unknown Linux", "", "")
     else:
         linux_distribution = None
     try:
-        msgpack_version = '.'.join(str(v) for v in msgpack.version)
+        msgpack_version = ".".join(str(v) for v in msgpack.version)
     except:
-        msgpack_version = 'unknown'
+        msgpack_version = "unknown"
     from ..fuse_impl import llfuse, BORG_FUSE_IMPL
-    llfuse_name = llfuse.__name__ if llfuse else 'None'
-    llfuse_version = (' %s' % llfuse.__version__) if llfuse else ''
-    llfuse_info = f'{llfuse_name}{llfuse_version} [{BORG_FUSE_IMPL}]'
+
+    llfuse_name = llfuse.__name__ if llfuse else "None"
+    llfuse_version = (" %s" % llfuse.__version__) if llfuse else ""
+    llfuse_info = f"{llfuse_name}{llfuse_version} [{BORG_FUSE_IMPL}]"
     info = []
     if uname is not None:
-        info.append('Platform: {}'.format(' '.join(uname)))
+        info.append("Platform: {}".format(" ".join(uname)))
     if linux_distribution is not None:
-        info.append('Linux: %s %s %s' % linux_distribution)
-    info.append('Borg: {}  Python: {} {} msgpack: {} fuse: {}'.format(
-                borg_version, python_implementation, python_version, msgpack_version, llfuse_info))
-    info.append('PID: %d  CWD: %s' % (os.getpid(), os.getcwd()))
-    info.append('sys.argv: %r' % sys.argv)
-    info.append('SSH_ORIGINAL_COMMAND: %r' % os.environ.get('SSH_ORIGINAL_COMMAND'))
-    info.append('')
-    return '\n'.join(info)
+        info.append("Linux: %s %s %s" % linux_distribution)
+    info.append(
+        "Borg: {}  Python: {} {} msgpack: {} fuse: {}".format(
+            borg_version, python_implementation, python_version, msgpack_version, llfuse_info
+        )
+    )
+    info.append("PID: %d  CWD: %s" % (os.getpid(), os.getcwd()))
+    info.append("sys.argv: %r" % sys.argv)
+    info.append("SSH_ORIGINAL_COMMAND: %r" % os.environ.get("SSH_ORIGINAL_COMMAND"))
+    info.append("")
+    return "\n".join(info)
 
 
 def log_multi(*msgs, level=logging.INFO, logger=logger):
@@ -133,7 +140,7 @@ class ChunkIteratorFileWrapper:
         """
         self.chunk_iterator = chunk_iterator
         self.chunk_offset = 0
-        self.chunk = b''
+        self.chunk = b""
         self.exhausted = False
         self.read_callback = read_callback
 
@@ -152,11 +159,11 @@ class ChunkIteratorFileWrapper:
 
     def _read(self, nbytes):
         if not nbytes:
-            return b''
+            return b""
         remaining = self._refill()
         will_read = min(remaining, nbytes)
         self.chunk_offset += will_read
-        return self.chunk[self.chunk_offset - will_read:self.chunk_offset]
+        return self.chunk[self.chunk_offset - will_read : self.chunk_offset]
 
     def read(self, nbytes):
         parts = []
@@ -166,7 +173,7 @@ class ChunkIteratorFileWrapper:
             parts.append(read_data)
             if self.read_callback:
                 self.read_callback(read_data)
-        return b''.join(parts)
+        return b"".join(parts)
 
 
 def open_item(archive, item):
@@ -207,7 +214,7 @@ class ErrorIgnoringTextIOWrapper(io.TextIOWrapper):
                     super().close()
                 except OSError:
                     pass
-        return ''
+        return ""
 
     def write(self, s):
         if not self.closed:
@@ -225,8 +232,8 @@ def iter_separated(fd, sep=None, read_size=4096):
     """Iter over chunks of open file ``fd`` delimited by ``sep``. Doesn't trim."""
     buf = fd.read(read_size)
     is_str = isinstance(buf, str)
-    part = '' if is_str else b''
-    sep = sep or ('\n' if is_str else b'\n')
+    part = "" if is_str else b""
+    sep = sep or ("\n" if is_str else b"\n")
     while len(buf) > 0:
         part2, *items = buf.split(sep)
         *full, part = (part + part2, *items)
@@ -240,17 +247,17 @@ def iter_separated(fd, sep=None, read_size=4096):
 
 def get_tar_filter(fname, decompress):
     # Note that filter is None if fname is '-'.
-    if fname.endswith(('.tar.gz', '.tgz')):
-        filter = 'gzip -d' if decompress else 'gzip'
-    elif fname.endswith(('.tar.bz2', '.tbz')):
-        filter = 'bzip2 -d' if decompress else 'bzip2'
-    elif fname.endswith(('.tar.xz', '.txz')):
-        filter = 'xz -d' if decompress else 'xz'
-    elif fname.endswith(('.tar.lz4', )):
-        filter = 'lz4 -d' if decompress else 'lz4'
-    elif fname.endswith(('.tar.zstd', )):
-        filter = 'zstd -d' if decompress else 'zstd'
+    if fname.endswith((".tar.gz", ".tgz")):
+        filter = "gzip -d" if decompress else "gzip"
+    elif fname.endswith((".tar.bz2", ".tbz")):
+        filter = "bzip2 -d" if decompress else "bzip2"
+    elif fname.endswith((".tar.xz", ".txz")):
+        filter = "xz -d" if decompress else "xz"
+    elif fname.endswith((".tar.lz4",)):
+        filter = "lz4 -d" if decompress else "lz4"
+    elif fname.endswith((".tar.zstd",)):
+        filter = "zstd -d" if decompress else "zstd"
     else:
         filter = None
-    logger.debug('Automatically determined tar filter: %s', filter)
+    logger.debug("Automatically determined tar filter: %s", filter)
     return filter
diff --git a/src/borg/helpers/msgpack.py b/src/borg/helpers/msgpack.py
index c1e753dff..0ea51d019 100644
--- a/src/borg/helpers/msgpack.py
+++ b/src/borg/helpers/msgpack.py
@@ -64,7 +64,7 @@ version = mp_version
 
 USE_BIN_TYPE = True
 RAW = False
-UNICODE_ERRORS = 'surrogateescape'
+UNICODE_ERRORS = "surrogateescape"
 
 
 class PackException(Exception):
@@ -76,13 +76,25 @@ class UnpackException(Exception):
 
 
 class Packer(mp_Packer):
-    def __init__(self, *, default=None, unicode_errors=UNICODE_ERRORS,
-                 use_single_float=False, autoreset=True, use_bin_type=USE_BIN_TYPE,
-                 strict_types=False):
+    def __init__(
+        self,
+        *,
+        default=None,
+        unicode_errors=UNICODE_ERRORS,
+        use_single_float=False,
+        autoreset=True,
+        use_bin_type=USE_BIN_TYPE,
+        strict_types=False
+    ):
         assert unicode_errors == UNICODE_ERRORS
-        super().__init__(default=default, unicode_errors=unicode_errors,
-                         use_single_float=use_single_float, autoreset=autoreset, use_bin_type=use_bin_type,
-                         strict_types=strict_types)
+        super().__init__(
+            default=default,
+            unicode_errors=unicode_errors,
+            use_single_float=use_single_float,
+            autoreset=autoreset,
+            use_bin_type=use_bin_type,
+            strict_types=strict_types,
+        )
 
     def pack(self, obj):
         try:
@@ -108,18 +120,36 @@ def pack(o, stream, *, use_bin_type=USE_BIN_TYPE, unicode_errors=UNICODE_ERRORS,
 
 
 class Unpacker(mp_Unpacker):
-    def __init__(self, file_like=None, *, read_size=0, use_list=True, raw=RAW,
-                 object_hook=None, object_pairs_hook=None, list_hook=None,
-                 unicode_errors=UNICODE_ERRORS, max_buffer_size=0,
-                 ext_hook=ExtType,
-                 strict_map_key=False):
+    def __init__(
+        self,
+        file_like=None,
+        *,
+        read_size=0,
+        use_list=True,
+        raw=RAW,
+        object_hook=None,
+        object_pairs_hook=None,
+        list_hook=None,
+        unicode_errors=UNICODE_ERRORS,
+        max_buffer_size=0,
+        ext_hook=ExtType,
+        strict_map_key=False
+    ):
         assert raw == RAW
         assert unicode_errors == UNICODE_ERRORS
-        kw = dict(file_like=file_like, read_size=read_size, use_list=use_list, raw=raw,
-                  object_hook=object_hook, object_pairs_hook=object_pairs_hook, list_hook=list_hook,
-                  unicode_errors=unicode_errors, max_buffer_size=max_buffer_size,
-                  ext_hook=ext_hook,
-                  strict_map_key=strict_map_key)
+        kw = dict(
+            file_like=file_like,
+            read_size=read_size,
+            use_list=use_list,
+            raw=raw,
+            object_hook=object_hook,
+            object_pairs_hook=object_pairs_hook,
+            list_hook=list_hook,
+            unicode_errors=unicode_errors,
+            max_buffer_size=max_buffer_size,
+            ext_hook=ext_hook,
+            strict_map_key=strict_map_key,
+        )
         super().__init__(**kw)
 
     def unpack(self):
@@ -141,28 +171,22 @@ class Unpacker(mp_Unpacker):
     next = __next__
 
 
-def unpackb(packed, *, raw=RAW, unicode_errors=UNICODE_ERRORS,
-            strict_map_key=False,
-            **kwargs):
+def unpackb(packed, *, raw=RAW, unicode_errors=UNICODE_ERRORS, strict_map_key=False, **kwargs):
     assert raw == RAW
     assert unicode_errors == UNICODE_ERRORS
     try:
-        kw = dict(raw=raw, unicode_errors=unicode_errors,
-                  strict_map_key=strict_map_key)
+        kw = dict(raw=raw, unicode_errors=unicode_errors, strict_map_key=strict_map_key)
         kw.update(kwargs)
         return mp_unpackb(packed, **kw)
     except Exception as e:
         raise UnpackException(e)
 
 
-def unpack(stream, *, raw=RAW, unicode_errors=UNICODE_ERRORS,
-           strict_map_key=False,
-           **kwargs):
+def unpack(stream, *, raw=RAW, unicode_errors=UNICODE_ERRORS, strict_map_key=False, **kwargs):
     assert raw == RAW
     assert unicode_errors == UNICODE_ERRORS
     try:
-        kw = dict(raw=raw, unicode_errors=unicode_errors,
-                  strict_map_key=strict_map_key)
+        kw = dict(raw=raw, unicode_errors=unicode_errors, strict_map_key=strict_map_key)
         kw.update(kwargs)
         return mp_unpack(stream, **kw)
     except Exception as e:
@@ -171,32 +195,34 @@ def unpack(stream, *, raw=RAW, unicode_errors=UNICODE_ERRORS,
 
 # msgpacking related utilities -----------------------------------------------
 
+
 def is_slow_msgpack():
     import msgpack
     import msgpack.fallback
+
     return msgpack.Packer is msgpack.fallback.Packer
 
 
 def is_supported_msgpack():
     # DO NOT CHANGE OR REMOVE! See also requirements and comments in setup.py.
     import msgpack
-    return (1, 0, 3) <= msgpack.version <= (1, 0, 4) and \
-           msgpack.version not in []  # < add bad releases here to deny list
+
+    return (1, 0, 3) <= msgpack.version <= (
+        1,
+        0,
+        4,
+    ) and msgpack.version not in []  # < add bad releases here to deny list
 
 
 def get_limited_unpacker(kind):
     """return a limited Unpacker because we should not trust msgpack data received from remote"""
     # Note: msgpack >= 0.6.1 auto-computes DoS-safe max values from len(data) for
     #       unpack(data) or from max_buffer_size for Unpacker(max_buffer_size=N).
-    args = dict(use_list=False,  # return tuples, not lists
-                max_buffer_size=3 * max(BUFSIZE, MAX_OBJECT_SIZE),
-                )
-    if kind in ('server', 'client'):
+    args = dict(use_list=False, max_buffer_size=3 * max(BUFSIZE, MAX_OBJECT_SIZE))  # return tuples, not lists
+    if kind in ("server", "client"):
         pass  # nothing special
-    elif kind in ('manifest', 'key'):
-        args.update(dict(use_list=True,  # default value
-                         object_hook=StableDict,
-                         ))
+    elif kind in ("manifest", "key"):
+        args.update(dict(use_list=True, object_hook=StableDict))  # default value
     else:
         raise ValueError('kind must be "server", "client", "manifest" or "key"')
     return Unpacker(**args)
diff --git a/src/borg/helpers/parseformat.py b/src/borg/helpers/parseformat.py
index a9d2ac960..b058ada99 100644
--- a/src/borg/helpers/parseformat.py
+++ b/src/borg/helpers/parseformat.py
@@ -15,6 +15,7 @@ from functools import partial
 from string import Formatter
 
 from ..logger import create_logger
+
 logger = create_logger()
 
 from .errors import Error
@@ -28,34 +29,34 @@ from ..platformflags import is_win32
 
 
 def bin_to_hex(binary):
-    return hexlify(binary).decode('ascii')
+    return hexlify(binary).decode("ascii")
 
 
-def safe_decode(s, coding='utf-8', errors='surrogateescape'):
+def safe_decode(s, coding="utf-8", errors="surrogateescape"):
     """decode bytes to str, with round-tripping "invalid" bytes"""
     if s is None:
         return None
     return s.decode(coding, errors)
 
 
-def safe_encode(s, coding='utf-8', errors='surrogateescape'):
+def safe_encode(s, coding="utf-8", errors="surrogateescape"):
     """encode str to bytes, with round-tripping "invalid" bytes"""
     if s is None:
         return None
     return s.encode(coding, errors)
 
 
-def remove_surrogates(s, errors='replace'):
+def remove_surrogates(s, errors="replace"):
     """Replace surrogates generated by fsdecode with '?'"""
-    return s.encode('utf-8', errors).decode('utf-8')
+    return s.encode("utf-8", errors).decode("utf-8")
 
 
 def eval_escapes(s):
     """Evaluate literal escape sequences in a string (eg `\\n` -> `\n`)."""
-    return s.encode('ascii', 'backslashreplace').decode('unicode-escape')
+    return s.encode("ascii", "backslashreplace").decode("unicode-escape")
 
 
-def decode_dict(d, keys, encoding='utf-8', errors='surrogateescape'):
+def decode_dict(d, keys, encoding="utf-8", errors="surrogateescape"):
     for key in keys:
         if isinstance(d.get(key), bytes):
             d[key] = d[key].decode(encoding, errors)
@@ -66,13 +67,13 @@ def positive_int_validator(value):
     """argparse type for positive integers"""
     int_value = int(value)
     if int_value <= 0:
-        raise argparse.ArgumentTypeError('A positive integer is required: %s' % value)
+        raise argparse.ArgumentTypeError("A positive integer is required: %s" % value)
     return int_value
 
 
 def interval(s):
     """Convert a string representing a valid interval to a number of hours."""
-    multiplier = {'H': 1, 'd': 24, 'w': 24 * 7, 'm': 24 * 31, 'y': 24 * 365}
+    multiplier = {"H": 1, "d": 24, "w": 24 * 7, "m": 24 * 31, "y": 24 * 365}
 
     if s.endswith(tuple(multiplier.keys())):
         number = s[:-1]
@@ -80,8 +81,7 @@ def interval(s):
     else:
         # range suffixes in ascending multiplier order
         ranges = [k for k, v in sorted(multiplier.items(), key=lambda t: t[1])]
-        raise argparse.ArgumentTypeError(
-            f'Unexpected interval time unit "{s[-1]}": expected one of {ranges!r}')
+        raise argparse.ArgumentTypeError(f'Unexpected interval time unit "{s[-1]}": expected one of {ranges!r}')
 
     try:
         hours = int(number) * multiplier[suffix]
@@ -89,17 +89,16 @@ def interval(s):
         hours = -1
 
     if hours <= 0:
-        raise argparse.ArgumentTypeError(
-            'Unexpected interval number "%s": expected an integer greater than 0' % number)
+        raise argparse.ArgumentTypeError('Unexpected interval number "%s": expected an integer greater than 0' % number)
 
     return hours
 
 
 def ChunkerParams(s):
-    params = s.strip().split(',')
+    params = s.strip().split(",")
     count = len(params)
     if count == 0:
-        raise ValueError('no chunker params given')
+        raise ValueError("no chunker params given")
     algo = params[0].lower()
     if algo == CH_FIXED and 2 <= count <= 3:  # fixed, block_size[, header_size]
         block_size = int(params[1])
@@ -110,36 +109,36 @@ def ChunkerParams(s):
             # or in-memory chunk management.
             # choose the block (chunk) size wisely: if you have a lot of data and you cut
             # it into very small chunks, you are asking for trouble!
-            raise ValueError('block_size must not be less than 64 Bytes')
+            raise ValueError("block_size must not be less than 64 Bytes")
         if block_size > MAX_DATA_SIZE or header_size > MAX_DATA_SIZE:
-            raise ValueError('block_size and header_size must not exceed MAX_DATA_SIZE [%d]' % MAX_DATA_SIZE)
+            raise ValueError("block_size and header_size must not exceed MAX_DATA_SIZE [%d]" % MAX_DATA_SIZE)
         return algo, block_size, header_size
-    if algo == 'default' and count == 1:  # default
+    if algo == "default" and count == 1:  # default
         return CHUNKER_PARAMS
     # this must stay last as it deals with old-style compat mode (no algorithm, 4 params, buzhash):
     if algo == CH_BUZHASH and count == 5 or count == 4:  # [buzhash, ]chunk_min, chunk_max, chunk_mask, window_size
-        chunk_min, chunk_max, chunk_mask, window_size = (int(p) for p in params[count - 4:])
+        chunk_min, chunk_max, chunk_mask, window_size = (int(p) for p in params[count - 4 :])
         if not (chunk_min <= chunk_mask <= chunk_max):
-            raise ValueError('required: chunk_min <= chunk_mask <= chunk_max')
+            raise ValueError("required: chunk_min <= chunk_mask <= chunk_max")
         if chunk_min < 6:
             # see comment in 'fixed' algo check
-            raise ValueError('min. chunk size exponent must not be less than 6 (2^6 = 64B min. chunk size)')
+            raise ValueError("min. chunk size exponent must not be less than 6 (2^6 = 64B min. chunk size)")
         if chunk_max > 23:
-            raise ValueError('max. chunk size exponent must not be more than 23 (2^23 = 8MiB max. chunk size)')
+            raise ValueError("max. chunk size exponent must not be more than 23 (2^23 = 8MiB max. chunk size)")
         return CH_BUZHASH, chunk_min, chunk_max, chunk_mask, window_size
-    raise ValueError('invalid chunker params')
+    raise ValueError("invalid chunker params")
 
 
 def FilesCacheMode(s):
-    ENTRIES_MAP = dict(ctime='c', mtime='m', size='s', inode='i', rechunk='r', disabled='d')
-    VALID_MODES = ('cis', 'ims', 'cs', 'ms', 'cr', 'mr', 'd', 's')  # letters in alpha order
-    entries = set(s.strip().split(','))
+    ENTRIES_MAP = dict(ctime="c", mtime="m", size="s", inode="i", rechunk="r", disabled="d")
+    VALID_MODES = ("cis", "ims", "cs", "ms", "cr", "mr", "d", "s")  # letters in alpha order
+    entries = set(s.strip().split(","))
     if not entries <= set(ENTRIES_MAP):
-        raise ValueError('cache mode must be a comma-separated list of: %s' % ','.join(sorted(ENTRIES_MAP)))
+        raise ValueError("cache mode must be a comma-separated list of: %s" % ",".join(sorted(ENTRIES_MAP)))
     short_entries = {ENTRIES_MAP[entry] for entry in entries}
-    mode = ''.join(sorted(short_entries))
+    mode = "".join(sorted(short_entries))
     if mode not in VALID_MODES:
-        raise ValueError('cache mode short must be one of: %s' % ','.join(VALID_MODES))
+        raise ValueError("cache mode short must be one of: %s" % ",".join(VALID_MODES))
     return mode
 
 
@@ -151,9 +150,9 @@ def partial_format(format, mapping):
     """
     for key, value in mapping.items():
         key = re.escape(key)
-        format = re.sub(fr'(?<!\{{)((\{{{key}\}})|(\{{{key}:[^\}}]*\}}))',
-                        lambda match: match.group(1).format_map(mapping),
-                        format)
+        format = re.sub(
+            rf"(?<!\{{)((\{{{key}\}})|(\{{{key}:[^\}}]*\}}))", lambda match: match.group(1).format_map(mapping), format
+        )
     return format
 
 
@@ -162,7 +161,7 @@ class DatetimeWrapper:
         self.dt = dt
 
     def __format__(self, format_spec):
-        if format_spec == '':
+        if format_spec == "":
             format_spec = ISO_FORMAT_NO_USECS
         return self.dt.__format__(format_spec)
 
@@ -190,20 +189,21 @@ def format_line(format, data):
 def replace_placeholders(text, overrides={}):
     """Replace placeholders in text with their values."""
     from ..platform import fqdn, hostname, getosusername
+
     current_time = datetime.now(timezone.utc)
     data = {
-        'pid': os.getpid(),
-        'fqdn': fqdn,
-        'reverse-fqdn': '.'.join(reversed(fqdn.split('.'))),
-        'hostname': hostname,
-        'now': DatetimeWrapper(current_time.astimezone(None)),
-        'utcnow': DatetimeWrapper(current_time),
-        'user': getosusername(),
-        'uuid4': str(uuid.uuid4()),
-        'borgversion': borg_version,
-        'borgmajor': '%d' % borg_version_tuple[:1],
-        'borgminor': '%d.%d' % borg_version_tuple[:2],
-        'borgpatch': '%d.%d.%d' % borg_version_tuple[:3],
+        "pid": os.getpid(),
+        "fqdn": fqdn,
+        "reverse-fqdn": ".".join(reversed(fqdn.split("."))),
+        "hostname": hostname,
+        "now": DatetimeWrapper(current_time.astimezone(None)),
+        "utcnow": DatetimeWrapper(current_time),
+        "user": getosusername(),
+        "uuid4": str(uuid.uuid4()),
+        "borgversion": borg_version,
+        "borgmajor": "%d" % borg_version_tuple[:1],
+        "borgminor": "%d.%d" % borg_version_tuple[:2],
+        "borgpatch": "%d.%d.%d" % borg_version_tuple[:3],
         **overrides,
     }
     return format_line(text, data)
@@ -220,17 +220,17 @@ CommentSpec = replace_placeholders
 
 def SortBySpec(text):
     from .manifest import AI_HUMAN_SORT_KEYS
-    for token in text.split(','):
+
+    for token in text.split(","):
         if token not in AI_HUMAN_SORT_KEYS:
-            raise ValueError('Invalid sort key: %s' % token)
-    return text.replace('timestamp', 'ts')
+            raise ValueError("Invalid sort key: %s" % token)
+    return text.replace("timestamp", "ts")
 
 
 def format_file_size(v, precision=2, sign=False, iec=False):
-    """Format file size into a human friendly format
-    """
+    """Format file size into a human friendly format"""
     fn = sizeof_fmt_iec if iec else sizeof_fmt_decimal
-    return fn(v, suffix='B', sep=' ', precision=precision, sign=sign)
+    return fn(v, suffix="B", sep=" ", precision=precision, sign=sign)
 
 
 class FileSize(int):
@@ -250,22 +250,16 @@ def parse_file_size(s):
     suffix = s[-1]
     power = 1000
     try:
-        factor = {
-            'K': power,
-            'M': power**2,
-            'G': power**3,
-            'T': power**4,
-            'P': power**5,
-        }[suffix]
+        factor = {"K": power, "M": power**2, "G": power**3, "T": power**4, "P": power**5}[suffix]
         s = s[:-1]
     except KeyError:
         factor = 1
     return int(float(s) * factor)
 
 
-def sizeof_fmt(num, suffix='B', units=None, power=None, sep='', precision=2, sign=False):
-    sign = '+' if sign and num > 0 else ''
-    fmt = '{0:{1}.{2}f}{3}{4}{5}'
+def sizeof_fmt(num, suffix="B", units=None, power=None, sep="", precision=2, sign=False):
+    sign = "+" if sign and num > 0 else ""
+    fmt = "{0:{1}.{2}f}{3}{4}{5}"
     prec = 0
     for unit in units[:-1]:
         if abs(round(num, precision)) < power:
@@ -277,27 +271,37 @@ def sizeof_fmt(num, suffix='B', units=None, power=None, sep='', precision=2, sig
     return fmt.format(num, sign, prec, sep, unit, suffix)
 
 
-def sizeof_fmt_iec(num, suffix='B', sep='', precision=2, sign=False):
-    return sizeof_fmt(num, suffix=suffix, sep=sep, precision=precision, sign=sign,
-                      units=['', 'Ki', 'Mi', 'Gi', 'Ti', 'Pi', 'Ei', 'Zi', 'Yi'], power=1024)
+def sizeof_fmt_iec(num, suffix="B", sep="", precision=2, sign=False):
+    return sizeof_fmt(
+        num,
+        suffix=suffix,
+        sep=sep,
+        precision=precision,
+        sign=sign,
+        units=["", "Ki", "Mi", "Gi", "Ti", "Pi", "Ei", "Zi", "Yi"],
+        power=1024,
+    )
 
 
-def sizeof_fmt_decimal(num, suffix='B', sep='', precision=2, sign=False):
-    return sizeof_fmt(num, suffix=suffix, sep=sep, precision=precision, sign=sign,
-                      units=['', 'k', 'M', 'G', 'T', 'P', 'E', 'Z', 'Y'], power=1000)
+def sizeof_fmt_decimal(num, suffix="B", sep="", precision=2, sign=False):
+    return sizeof_fmt(
+        num,
+        suffix=suffix,
+        sep=sep,
+        precision=precision,
+        sign=sign,
+        units=["", "k", "M", "G", "T", "P", "E", "Z", "Y"],
+        power=1000,
+    )
 
 
 def format_archive(archive):
-    return '%-36s %s [%s]' % (
-        archive.name,
-        format_time(to_localtime(archive.ts)),
-        bin_to_hex(archive.id),
-    )
+    return "%-36s %s [%s]" % (archive.name, format_time(to_localtime(archive.ts)), bin_to_hex(archive.id))
 
 
 def parse_stringified_list(s):
     l = re.split(" *, *", s)
-    return [item for item in l if item != '']
+    return [item for item in l if item != ""]
 
 
 class Location:
@@ -343,28 +347,42 @@ class Location:
     """
 
     # regexes for misc. kinds of supported location specifiers:
-    ssh_re = re.compile(r"""
+    ssh_re = re.compile(
+        r"""
         (?P<proto>ssh)://                                       # ssh://
-        """ + optional_user_re + host_re + r"""                 # user@  (optional), host name or address
+        """
+        + optional_user_re
+        + host_re
+        + r"""                 # user@  (optional), host name or address
         (?::(?P<port>\d+))?                                     # :port (optional)
-        """ + abs_path_re, re.VERBOSE)                          # path
+        """
+        + abs_path_re,
+        re.VERBOSE,
+    )  # path
 
-    file_re = re.compile(r"""
+    file_re = re.compile(
+        r"""
         (?P<proto>file)://                                      # file://
-        """ + file_path_re, re.VERBOSE)                         # servername/path or path
+        """
+        + file_path_re,
+        re.VERBOSE,
+    )  # servername/path or path
 
-    local_re = re.compile(local_path_re, re.VERBOSE)            # local path
+    local_re = re.compile(local_path_re, re.VERBOSE)  # local path
 
-    win_file_re = re.compile(r"""
+    win_file_re = re.compile(
+        r"""
         (?:file://)?                                        # optional file protocol
         (?P<path>
             (?:[a-zA-Z]:)?                                  # Drive letter followed by a colon (optional)
             (?:[^:]+)                                       # Anything which does not contain a :, at least one character
         )
-        """, re.VERBOSE)
+        """,
+        re.VERBOSE,
+    )
 
-    def __init__(self, text='', overrides={}, other=False):
-        self.repo_env_var = 'BORG_OTHER_REPO' if other else 'BORG_REPO'
+    def __init__(self, text="", overrides={}, other=False):
+        self.repo_env_var = "BORG_OTHER_REPO" if other else "BORG_REPO"
         self.valid = False
         self.proto = None
         self.user = None
@@ -393,15 +411,15 @@ class Location:
     def _parse(self, text):
         def normpath_special(p):
             # avoid that normpath strips away our relative path hack and even makes p absolute
-            relative = p.startswith('/./')
+            relative = p.startswith("/./")
             p = os.path.normpath(p)
-            return ('/.' + p) if relative else p
+            return ("/." + p) if relative else p
 
         if is_win32:
             m = self.win_file_re.match(text)
             if m:
-                self.proto = 'file'
-                self.path = m.group('path')
+                self.proto = "file"
+                self.path = m.group("path")
                 return True
 
             # On windows we currently only support windows paths.
@@ -409,38 +427,38 @@ class Location:
 
         m = self.ssh_re.match(text)
         if m:
-            self.proto = m.group('proto')
-            self.user = m.group('user')
-            self._host = m.group('host')
-            self.port = m.group('port') and int(m.group('port')) or None
-            self.path = normpath_special(m.group('path'))
+            self.proto = m.group("proto")
+            self.user = m.group("user")
+            self._host = m.group("host")
+            self.port = m.group("port") and int(m.group("port")) or None
+            self.path = normpath_special(m.group("path"))
             return True
         m = self.file_re.match(text)
         if m:
-            self.proto = m.group('proto')
-            self.path = normpath_special(m.group('path'))
+            self.proto = m.group("proto")
+            self.path = normpath_special(m.group("path"))
             return True
         m = self.local_re.match(text)
         if m:
-            self.proto = 'file'
-            self.path = normpath_special(m.group('path'))
+            self.proto = "file"
+            self.path = normpath_special(m.group("path"))
             return True
         return False
 
     def __str__(self):
         items = [
-            'proto=%r' % self.proto,
-            'user=%r' % self.user,
-            'host=%r' % self.host,
-            'port=%r' % self.port,
-            'path=%r' % self.path,
+            "proto=%r" % self.proto,
+            "user=%r" % self.user,
+            "host=%r" % self.host,
+            "port=%r" % self.port,
+            "path=%r" % self.path,
         ]
-        return ', '.join(items)
+        return ", ".join(items)
 
     def to_key_filename(self):
-        name = re.sub(r'[^\w]', '_', self.path).strip('_')
-        if self.proto != 'file':
-            name = re.sub(r'[^\w]', '_', self.host) + '__' + name
+        name = re.sub(r"[^\w]", "_", self.path).strip("_")
+        if self.proto != "file":
+            name = re.sub(r"[^\w]", "_", self.host) + "__" + name
         if len(name) > 100:
             # Limit file names to some reasonable length. Most file systems
             # limit them to 255 [unit of choice]; due to variations in unicode
@@ -455,28 +473,30 @@ class Location:
     def host(self):
         # strip square brackets used for IPv6 addrs
         if self._host is not None:
-            return self._host.lstrip('[').rstrip(']')
+            return self._host.lstrip("[").rstrip("]")
 
     def canonical_path(self):
-        if self.proto == 'file':
+        if self.proto == "file":
             return self.path
         else:
-            if self.path and self.path.startswith('~'):
-                path = '/' + self.path  # /~/x = path x relative to home dir
-            elif self.path and not self.path.startswith('/'):
-                path = '/./' + self.path  # /./x = path x relative to cwd
+            if self.path and self.path.startswith("~"):
+                path = "/" + self.path  # /~/x = path x relative to home dir
+            elif self.path and not self.path.startswith("/"):
+                path = "/./" + self.path  # /./x = path x relative to cwd
             else:
                 path = self.path
-            return 'ssh://{}{}{}{}'.format(f'{self.user}@' if self.user else '',
-                                           self._host,  # needed for ipv6 addrs
-                                           f':{self.port}' if self.port else '',
-                                           path)
+            return "ssh://{}{}{}{}".format(
+                f"{self.user}@" if self.user else "",
+                self._host,  # needed for ipv6 addrs
+                f":{self.port}" if self.port else "",
+                path,
+            )
 
     def with_timestamp(self, timestamp):
-        return Location(self.raw, overrides={
-            'now': DatetimeWrapper(timestamp.astimezone(None)),
-            'utcnow': DatetimeWrapper(timestamp),
-        })
+        return Location(
+            self.raw,
+            overrides={"now": DatetimeWrapper(timestamp.astimezone(None)), "utcnow": DatetimeWrapper(timestamp)},
+        )
 
 
 def location_validator(proto=None, other=False):
@@ -486,33 +506,35 @@ def location_validator(proto=None, other=False):
         except ValueError as err:
             raise argparse.ArgumentTypeError(str(err)) from None
         if proto is not None and loc.proto != proto:
-            if proto == 'file':
+            if proto == "file":
                 raise argparse.ArgumentTypeError('"%s": Repository must be local' % text)
             else:
                 raise argparse.ArgumentTypeError('"%s": Repository must be remote' % text)
         return loc
+
     return validator
 
 
 def archivename_validator():
     def validator(text):
         text = replace_placeholders(text)
-        if '/' in text or '::' in text or not text:
+        if "/" in text or "::" in text or not text:
             raise argparse.ArgumentTypeError('Invalid archive name: "%s"' % text)
         return text
+
     return validator
 
 
 class BaseFormatter:
     FIXED_KEYS = {
         # Formatting aids
-        'LF': '\n',
-        'SPACE': ' ',
-        'TAB': '\t',
-        'CR': '\r',
-        'NUL': '\0',
-        'NEWLINE': os.linesep,
-        'NL': os.linesep,
+        "LF": "\n",
+        "SPACE": " ",
+        "TAB": "\t",
+        "CR": "\r",
+        "NUL": "\0",
+        "NEWLINE": os.linesep,
+        "NL": os.linesep,
     }
 
     def get_item_data(self, item):
@@ -523,42 +545,45 @@ class BaseFormatter:
 
     @staticmethod
     def keys_help():
-        return "- NEWLINE: OS dependent line separator\n" \
-               "- NL: alias of NEWLINE\n" \
-               "- NUL: NUL character for creating print0 / xargs -0 like output, see barchive and bpath keys below\n" \
-               "- SPACE\n" \
-               "- TAB\n" \
-               "- CR\n" \
-               "- LF"
+        return (
+            "- NEWLINE: OS dependent line separator\n"
+            "- NL: alias of NEWLINE\n"
+            "- NUL: NUL character for creating print0 / xargs -0 like output, see barchive and bpath keys below\n"
+            "- SPACE\n"
+            "- TAB\n"
+            "- CR\n"
+            "- LF"
+        )
 
 
 class ArchiveFormatter(BaseFormatter):
     KEY_DESCRIPTIONS = {
-        'archive': 'archive name interpreted as text (might be missing non-text characters, see barchive)',
-        'name': 'alias of "archive"',
-        'barchive': 'verbatim archive name, can contain any character except NUL',
-        'comment': 'archive comment interpreted as text (might be missing non-text characters, see bcomment)',
-        'bcomment': 'verbatim archive comment, can contain any character except NUL',
+        "archive": "archive name interpreted as text (might be missing non-text characters, see barchive)",
+        "name": 'alias of "archive"',
+        "barchive": "verbatim archive name, can contain any character except NUL",
+        "comment": "archive comment interpreted as text (might be missing non-text characters, see bcomment)",
+        "bcomment": "verbatim archive comment, can contain any character except NUL",
         # *start* is the key used by borg-info for this timestamp, this makes the formats more compatible
-        'start': 'time (start) of creation of the archive',
-        'time': 'alias of "start"',
-        'end': 'time (end) of creation of the archive',
-        'command_line': 'command line which was used to create the archive',
-        'id': 'internal ID of the archive',
-        'hostname': 'hostname of host on which this archive was created',
-        'username': 'username of user who created this archive',
+        "start": "time (start) of creation of the archive",
+        "time": 'alias of "start"',
+        "end": "time (end) of creation of the archive",
+        "command_line": "command line which was used to create the archive",
+        "id": "internal ID of the archive",
+        "hostname": "hostname of host on which this archive was created",
+        "username": "username of user who created this archive",
     }
     KEY_GROUPS = (
-        ('archive', 'name', 'barchive', 'comment', 'bcomment', 'id'),
-        ('start', 'time', 'end', 'command_line'),
-        ('hostname', 'username'),
+        ("archive", "name", "barchive", "comment", "bcomment", "id"),
+        ("start", "time", "end", "command_line"),
+        ("hostname", "username"),
     )
 
     @classmethod
     def available_keys(cls):
         from .manifest import ArchiveInfo
-        fake_archive_info = ArchiveInfo('archivename', b'\1'*32, datetime(1970, 1, 1, tzinfo=timezone.utc))
-        formatter = cls('', None, None, None)
+
+        fake_archive_info = ArchiveInfo("archivename", b"\1" * 32, datetime(1970, 1, 1, tzinfo=timezone.utc))
+        formatter = cls("", None, None, None)
         keys = []
         keys.extend(formatter.call_keys.keys())
         keys.extend(formatter.get_item_data(fake_archive_info).keys())
@@ -596,12 +621,12 @@ class ArchiveFormatter(BaseFormatter):
         self.format = partial_format(format, static_keys)
         self.format_keys = {f[1] for f in Formatter().parse(format)}
         self.call_keys = {
-            'hostname': partial(self.get_meta, 'hostname', rs=True),
-            'username': partial(self.get_meta, 'username', rs=True),
-            'comment': partial(self.get_meta, 'comment', rs=True),
-            'bcomment': partial(self.get_meta, 'comment', rs=False),
-            'end': self.get_ts_end,
-            'command_line': self.get_cmdline,
+            "hostname": partial(self.get_meta, "hostname", rs=True),
+            "username": partial(self.get_meta, "username", rs=True),
+            "comment": partial(self.get_meta, "comment", rs=True),
+            "bcomment": partial(self.get_meta, "comment", rs=False),
+            "end": self.get_ts_end,
+            "command_line": self.get_cmdline,
         }
         self.used_call_keys = set(self.call_keys) & self.format_keys
         if self.json:
@@ -611,21 +636,23 @@ class ArchiveFormatter(BaseFormatter):
             self.item_data = static_keys
 
     def format_item_json(self, item):
-        return json.dumps(self.get_item_data(item), cls=BorgJsonEncoder) + '\n'
+        return json.dumps(self.get_item_data(item), cls=BorgJsonEncoder) + "\n"
 
     def get_item_data(self, archive_info):
         self.name = archive_info.name
         self.id = archive_info.id
         item_data = {}
         item_data.update(self.item_data)
-        item_data.update({
-            'name': remove_surrogates(archive_info.name),
-            'archive': remove_surrogates(archive_info.name),
-            'barchive': archive_info.name,
-            'id': bin_to_hex(archive_info.id),
-            'time': self.format_time(archive_info.ts),
-            'start': self.format_time(archive_info.ts),
-        })
+        item_data.update(
+            {
+                "name": remove_surrogates(archive_info.name),
+                "archive": remove_surrogates(archive_info.name),
+                "barchive": archive_info.name,
+                "id": bin_to_hex(archive_info.id),
+                "time": self.format_time(archive_info.ts),
+                "start": self.format_time(archive_info.ts),
+            }
+        )
         for key in self.used_call_keys:
             item_data[key] = self.call_keys[key]()
         return item_data
@@ -635,19 +662,20 @@ class ArchiveFormatter(BaseFormatter):
         """lazy load / update loaded archive"""
         if self._archive is None or self._archive.id != self.id:
             from ..archive import Archive
+
             self._archive = Archive(self.repository, self.key, self.manifest, self.name, iec=self.iec)
         return self._archive
 
     def get_meta(self, key, rs):
-        value = self.archive.metadata.get(key, '')
+        value = self.archive.metadata.get(key, "")
         return remove_surrogates(value) if rs else value
 
     def get_cmdline(self):
-        cmdline = map(remove_surrogates, self.archive.metadata.get('cmdline', []))
+        cmdline = map(remove_surrogates, self.archive.metadata.get("cmdline", []))
         if self.json:
             return list(cmdline)
         else:
-            return ' '.join(map(shlex.quote, cmdline))
+            return " ".join(map(shlex.quote, cmdline))
 
     def get_ts_end(self):
         return self.format_time(self.archive.ts_end)
@@ -659,31 +687,29 @@ class ArchiveFormatter(BaseFormatter):
 class ItemFormatter(BaseFormatter):
     # we provide the hash algos from python stdlib (except shake_*) and additionally xxh64.
     # shake_* is not provided because it uses an incompatible .digest() method to support variable length.
-    hash_algorithms = hashlib.algorithms_guaranteed.union({'xxh64'}).difference({'shake_128', 'shake_256'})
+    hash_algorithms = hashlib.algorithms_guaranteed.union({"xxh64"}).difference({"shake_128", "shake_256"})
     KEY_DESCRIPTIONS = {
-        'bpath': 'verbatim POSIX path, can contain any character except NUL',
-        'path': 'path interpreted as text (might be missing non-text characters, see bpath)',
-        'source': 'link target for symlinks (identical to linktarget)',
-        'hlid': 'hard link identity (same if hardlinking same fs object)',
-        'extra': 'prepends {source} with " -> " for soft links and " link to " for hard links',
-        'dsize': 'deduplicated size',
-        'num_chunks': 'number of chunks in this file',
-        'unique_chunks': 'number of unique chunks in this file',
-        'xxh64': 'XXH64 checksum of this file (note: this is NOT a cryptographic hash!)',
-        'health': 'either "healthy" (file ok) or "broken" (if file has all-zero replacement chunks)',
+        "bpath": "verbatim POSIX path, can contain any character except NUL",
+        "path": "path interpreted as text (might be missing non-text characters, see bpath)",
+        "source": "link target for symlinks (identical to linktarget)",
+        "hlid": "hard link identity (same if hardlinking same fs object)",
+        "extra": 'prepends {source} with " -> " for soft links and " link to " for hard links',
+        "dsize": "deduplicated size",
+        "num_chunks": "number of chunks in this file",
+        "unique_chunks": "number of unique chunks in this file",
+        "xxh64": "XXH64 checksum of this file (note: this is NOT a cryptographic hash!)",
+        "health": 'either "healthy" (file ok) or "broken" (if file has all-zero replacement chunks)',
     }
     KEY_GROUPS = (
-        ('type', 'mode', 'uid', 'gid', 'user', 'group', 'path', 'bpath', 'source', 'linktarget', 'hlid', 'flags'),
-        ('size', 'dsize', 'num_chunks', 'unique_chunks'),
-        ('mtime', 'ctime', 'atime', 'isomtime', 'isoctime', 'isoatime'),
+        ("type", "mode", "uid", "gid", "user", "group", "path", "bpath", "source", "linktarget", "hlid", "flags"),
+        ("size", "dsize", "num_chunks", "unique_chunks"),
+        ("mtime", "ctime", "atime", "isomtime", "isoctime", "isoatime"),
         tuple(sorted(hash_algorithms)),
-        ('archiveid', 'archivename', 'extra'),
-        ('health', )
+        ("archiveid", "archivename", "extra"),
+        ("health",),
     )
 
-    KEYS_REQUIRING_CACHE = (
-        'dsize', 'unique_chunks',
-    )
+    KEYS_REQUIRING_CACHE = ("dsize", "unique_chunks")
 
     @classmethod
     def available_keys(cls):
@@ -691,7 +717,8 @@ class ItemFormatter(BaseFormatter):
             fpr = name = ""
 
         from ..item import Item
-        fake_item = Item(mode=0, path='', user='', group='', mtime=0, uid=0, gid=0)
+
+        fake_item = Item(mode=0, path="", user="", group="", mtime=0, uid=0, gid=0)
         formatter = cls(FakeArchive, "")
         keys = []
         keys.extend(formatter.call_keys.keys())
@@ -723,13 +750,11 @@ class ItemFormatter(BaseFormatter):
 
     def __init__(self, archive, format, *, json_lines=False):
         from ..checksums import StreamingXXH64
+
         self.xxh64 = StreamingXXH64
         self.archive = archive
         self.json_lines = json_lines
-        static_keys = {
-            'archivename': archive.name,
-            'archiveid': archive.fpr,
-        }
+        static_keys = {"archivename": archive.name, "archiveid": archive.fpr}
         static_keys.update(self.FIXED_KEYS)
         if self.json_lines:
             self.item_data = {}
@@ -739,23 +764,23 @@ class ItemFormatter(BaseFormatter):
         self.format = partial_format(format, static_keys)
         self.format_keys = {f[1] for f in Formatter().parse(format)}
         self.call_keys = {
-            'size': self.calculate_size,
-            'dsize': partial(self.sum_unique_chunks_metadata, lambda chunk: chunk.size),
-            'num_chunks': self.calculate_num_chunks,
-            'unique_chunks': partial(self.sum_unique_chunks_metadata, lambda chunk: 1),
-            'isomtime': partial(self.format_iso_time, 'mtime'),
-            'isoctime': partial(self.format_iso_time, 'ctime'),
-            'isoatime': partial(self.format_iso_time, 'atime'),
-            'mtime': partial(self.format_time, 'mtime'),
-            'ctime': partial(self.format_time, 'ctime'),
-            'atime': partial(self.format_time, 'atime'),
+            "size": self.calculate_size,
+            "dsize": partial(self.sum_unique_chunks_metadata, lambda chunk: chunk.size),
+            "num_chunks": self.calculate_num_chunks,
+            "unique_chunks": partial(self.sum_unique_chunks_metadata, lambda chunk: 1),
+            "isomtime": partial(self.format_iso_time, "mtime"),
+            "isoctime": partial(self.format_iso_time, "ctime"),
+            "isoatime": partial(self.format_iso_time, "atime"),
+            "mtime": partial(self.format_time, "mtime"),
+            "ctime": partial(self.format_time, "ctime"),
+            "atime": partial(self.format_time, "atime"),
         }
         for hash_function in self.hash_algorithms:
             self.call_keys[hash_function] = partial(self.hash_item, hash_function)
         self.used_call_keys = set(self.call_keys) & self.format_keys
 
     def format_item_json(self, item):
-        return json.dumps(self.get_item_data(item), cls=BorgJsonEncoder) + '\n'
+        return json.dumps(self.get_item_data(item), cls=BorgJsonEncoder) + "\n"
 
     def get_item_data(self, item):
         item_data = {}
@@ -763,30 +788,30 @@ class ItemFormatter(BaseFormatter):
         mode = stat.filemode(item.mode)
         item_type = mode[0]
 
-        source = item.get('source', '')
-        extra = ''
+        source = item.get("source", "")
+        extra = ""
         if source:
             source = remove_surrogates(source)
-            extra = ' -> %s' % source
-        hlid = item.get('hlid')
-        hlid = bin_to_hex(hlid) if hlid else ''
-        item_data['type'] = item_type
-        item_data['mode'] = mode
-        item_data['user'] = item.get('user', str(item.uid))
-        item_data['group'] = item.get('group', str(item.gid))
-        item_data['uid'] = item.uid
-        item_data['gid'] = item.gid
-        item_data['path'] = remove_surrogates(item.path)
+            extra = " -> %s" % source
+        hlid = item.get("hlid")
+        hlid = bin_to_hex(hlid) if hlid else ""
+        item_data["type"] = item_type
+        item_data["mode"] = mode
+        item_data["user"] = item.get("user", str(item.uid))
+        item_data["group"] = item.get("group", str(item.gid))
+        item_data["uid"] = item.uid
+        item_data["gid"] = item.gid
+        item_data["path"] = remove_surrogates(item.path)
         if self.json_lines:
-            item_data['healthy'] = 'chunks_healthy' not in item
+            item_data["healthy"] = "chunks_healthy" not in item
         else:
-            item_data['bpath'] = item.path
-            item_data['extra'] = extra
-            item_data['health'] = 'broken' if 'chunks_healthy' in item else 'healthy'
-        item_data['source'] = source
-        item_data['linktarget'] = source
-        item_data['hlid'] = hlid
-        item_data['flags'] = item.get('bsdflags')
+            item_data["bpath"] = item.path
+            item_data["extra"] = extra
+            item_data["health"] = "broken" if "chunks_healthy" in item else "healthy"
+        item_data["source"] = source
+        item_data["linktarget"] = source
+        item_data["hlid"] = hlid
+        item_data["flags"] = item.get("bsdflags")
         for key in self.used_call_keys:
             item_data[key] = self.call_keys[key](item)
         return item_data
@@ -801,21 +826,21 @@ class ItemFormatter(BaseFormatter):
                        the metadata needed from the chunk
         """
         chunk_index = self.archive.cache.chunks
-        chunks = item.get('chunks', [])
+        chunks = item.get("chunks", [])
         chunks_counter = Counter(c.id for c in chunks)
         return sum(metadata_func(c) for c in chunks if chunk_index[c.id].refcount == chunks_counter[c.id])
 
     def calculate_num_chunks(self, item):
-        return len(item.get('chunks', []))
+        return len(item.get("chunks", []))
 
     def calculate_size(self, item):
         # note: does not support hardlink slaves, they will be size 0
         return item.get_size()
 
     def hash_item(self, hash_function, item):
-        if 'chunks' not in item:
+        if "chunks" not in item:
             return ""
-        if hash_function == 'xxh64':
+        if hash_function == "xxh64":
             hash = self.xxh64()
         elif hash_function in self.hash_algorithms:
             hash = hashlib.new(hash_function)
@@ -832,18 +857,18 @@ class ItemFormatter(BaseFormatter):
 
 def file_status(mode):
     if stat.S_ISREG(mode):
-        return 'A'
+        return "A"
     elif stat.S_ISDIR(mode):
-        return 'd'
+        return "d"
     elif stat.S_ISBLK(mode):
-        return 'b'
+        return "b"
     elif stat.S_ISCHR(mode):
-        return 'c'
+        return "c"
     elif stat.S_ISLNK(mode):
-        return 's'
+        return "s"
     elif stat.S_ISFIFO(mode):
-        return 'f'
-    return '?'
+        return "f"
+    return "?"
 
 
 def clean_lines(lines, lstrip=None, rstrip=None, remove_empty=True, remove_comments=True):
@@ -868,7 +893,7 @@ def clean_lines(lines, lstrip=None, rstrip=None, remove_empty=True, remove_comme
             line = line.rstrip(rstrip)
         if remove_empty and not line:
             continue
-        if remove_comments and line.startswith('#'):
+        if remove_comments and line.startswith("#"):
             continue
         yield line
 
@@ -883,6 +908,7 @@ def swidth_slice(string, max_width):
     Latin characters are usually one cell wide, many CJK characters are two cells wide.
     """
     from ..platform import swidth
+
     reverse = max_width < 0
     max_width = abs(max_width)
     if reverse:
@@ -896,7 +922,7 @@ def swidth_slice(string, max_width):
         result.append(character)
     if reverse:
         result.reverse()
-    return ''.join(result)
+    return "".join(result)
 
 
 def ellipsis_truncate(msg, space):
@@ -905,15 +931,15 @@ def ellipsis_truncate(msg, space):
     this_is_a_very_long_string -------> this_is..._string
     """
     from ..platform import swidth
-    ellipsis_width = swidth('...')
+
+    ellipsis_width = swidth("...")
     msg_width = swidth(msg)
     if space < 8:
         # if there is very little space, just show ...
-        return '...' + ' ' * (space - ellipsis_width)
+        return "..." + " " * (space - ellipsis_width)
     if space < ellipsis_width + msg_width:
-        return '{}...{}'.format(swidth_slice(msg, space // 2 - ellipsis_width),
-                                swidth_slice(msg, -space // 2))
-    return msg + ' ' * (space - msg_width)
+        return "{}...{}".format(swidth_slice(msg, space // 2 - ellipsis_width), swidth_slice(msg, -space // 2))
+    return msg + " " * (space - msg_width)
 
 
 class BorgJsonEncoder(json.JSONEncoder):
@@ -922,23 +948,16 @@ class BorgJsonEncoder(json.JSONEncoder):
         from ..remote import RemoteRepository
         from ..archive import Archive
         from ..cache import LocalCache, AdHocCache
+
         if isinstance(o, Repository) or isinstance(o, RemoteRepository):
-            return {
-                'id': bin_to_hex(o.id),
-                'location': o._location.canonical_path(),
-            }
+            return {"id": bin_to_hex(o.id), "location": o._location.canonical_path()}
         if isinstance(o, Archive):
             return o.info()
         if isinstance(o, LocalCache):
-            return {
-                'path': o.path,
-                'stats': o.stats(),
-            }
+            return {"path": o.path, "stats": o.stats()}
         if isinstance(o, AdHocCache):
-            return {
-                'stats': o.stats(),
-            }
-        if callable(getattr(o, 'to_json', None)):
+            return {"stats": o.stats()}
+        if callable(getattr(o, "to_json", None)):
             return o.to_json()
         return super().default(o)
 
@@ -946,17 +965,12 @@ class BorgJsonEncoder(json.JSONEncoder):
 def basic_json_data(manifest, *, cache=None, extra=None):
     key = manifest.key
     data = extra or {}
-    data.update({
-        'repository': BorgJsonEncoder().default(manifest.repository),
-        'encryption': {
-            'mode': key.ARG_NAME,
-        },
-    })
-    data['repository']['last_modified'] = OutputTimestamp(manifest.last_timestamp.replace(tzinfo=timezone.utc))
-    if key.NAME.startswith('key file'):
-        data['encryption']['keyfile'] = key.find_key()
+    data.update({"repository": BorgJsonEncoder().default(manifest.repository), "encryption": {"mode": key.ARG_NAME}})
+    data["repository"]["last_modified"] = OutputTimestamp(manifest.last_timestamp.replace(tzinfo=timezone.utc))
+    if key.NAME.startswith("key file"):
+        data["encryption"]["keyfile"] = key.find_key()
     if cache:
-        data['cache'] = cache
+        data["cache"] = cache
     return data
 
 
@@ -975,13 +989,13 @@ def prepare_dump_dict(d):
         # look nice and chunk ids should mostly show in hex. Use a special
         # inband signaling character (ASCII DEL) to distinguish between
         # decoded and hex mode.
-        if not value.startswith(b'\x7f'):
+        if not value.startswith(b"\x7f"):
             try:
                 value = value.decode()
                 return value
             except UnicodeDecodeError:
                 pass
-        return '\u007f' + bin_to_hex(value)
+        return "\u007f" + bin_to_hex(value)
 
     def decode_tuple(t):
         res = []
diff --git a/src/borg/helpers/passphrase.py b/src/borg/helpers/passphrase.py
index b53e26ad1..6aa8b4327 100644
--- a/src/borg/helpers/passphrase.py
+++ b/src/borg/helpers/passphrase.py
@@ -39,7 +39,7 @@ class Passphrase(str):
 
     @classmethod
     def env_passphrase(cls, default=None):
-        passphrase = cls._env_passphrase('BORG_PASSPHRASE', default)
+        passphrase = cls._env_passphrase("BORG_PASSPHRASE", default)
         if passphrase is not None:
             return passphrase
         passphrase = cls.env_passcommand()
@@ -51,7 +51,7 @@ class Passphrase(str):
 
     @classmethod
     def env_passcommand(cls, default=None):
-        passcommand = os.environ.get('BORG_PASSCOMMAND', None)
+        passcommand = os.environ.get("BORG_PASSCOMMAND", None)
         if passcommand is not None:
             # passcommand is a system command (not inside pyinstaller env)
             env = prepare_subprocess_env(system=True)
@@ -59,21 +59,21 @@ class Passphrase(str):
                 passphrase = subprocess.check_output(shlex.split(passcommand), universal_newlines=True, env=env)
             except (subprocess.CalledProcessError, FileNotFoundError) as e:
                 raise PasscommandFailure(e)
-            return cls(passphrase.rstrip('\n'))
+            return cls(passphrase.rstrip("\n"))
 
     @classmethod
     def fd_passphrase(cls):
         try:
-            fd = int(os.environ.get('BORG_PASSPHRASE_FD'))
+            fd = int(os.environ.get("BORG_PASSPHRASE_FD"))
         except (ValueError, TypeError):
             return None
-        with os.fdopen(fd, mode='r') as f:
+        with os.fdopen(fd, mode="r") as f:
             passphrase = f.read()
-        return cls(passphrase.rstrip('\n'))
+        return cls(passphrase.rstrip("\n"))
 
     @classmethod
     def env_new_passphrase(cls, default=None):
-        return cls._env_passphrase('BORG_NEW_PASSPHRASE', default)
+        return cls._env_passphrase("BORG_NEW_PASSPHRASE", default)
 
     @classmethod
     def getpass(cls, prompt):
@@ -83,32 +83,38 @@ class Passphrase(str):
             if prompt:
                 print()  # avoid err msg appearing right of prompt
             msg = []
-            for env_var in 'BORG_PASSPHRASE', 'BORG_PASSCOMMAND':
+            for env_var in "BORG_PASSPHRASE", "BORG_PASSCOMMAND":
                 env_var_set = os.environ.get(env_var) is not None
-                msg.append('{} is {}.'.format(env_var, 'set' if env_var_set else 'not set'))
-            msg.append('Interactive password query failed.')
-            raise NoPassphraseFailure(' '.join(msg)) from None
+                msg.append("{} is {}.".format(env_var, "set" if env_var_set else "not set"))
+            msg.append("Interactive password query failed.")
+            raise NoPassphraseFailure(" ".join(msg)) from None
         else:
             return cls(pw)
 
     @classmethod
     def verification(cls, passphrase):
-        msg = 'Do you want your passphrase to be displayed for verification? [yN]: '
-        if yes(msg, retry_msg=msg, invalid_msg='Invalid answer, try again.',
-               retry=True, env_var_override='BORG_DISPLAY_PASSPHRASE'):
-            print('Your passphrase (between double-quotes): "%s"' % passphrase,
-                  file=sys.stderr)
-            print('Make sure the passphrase displayed above is exactly what you wanted.',
-                  file=sys.stderr)
+        msg = "Do you want your passphrase to be displayed for verification? [yN]: "
+        if yes(
+            msg,
+            retry_msg=msg,
+            invalid_msg="Invalid answer, try again.",
+            retry=True,
+            env_var_override="BORG_DISPLAY_PASSPHRASE",
+        ):
+            print('Your passphrase (between double-quotes): "%s"' % passphrase, file=sys.stderr)
+            print("Make sure the passphrase displayed above is exactly what you wanted.", file=sys.stderr)
             try:
-                passphrase.encode('ascii')
+                passphrase.encode("ascii")
             except UnicodeEncodeError:
-                print('Your passphrase (UTF-8 encoding in hex): %s' %
-                      bin_to_hex(passphrase.encode('utf-8')),
-                      file=sys.stderr)
-                print('As you have a non-ASCII passphrase, it is recommended to keep the '
-                      'UTF-8 encoding in hex together with the passphrase at a safe place.',
-                      file=sys.stderr)
+                print(
+                    "Your passphrase (UTF-8 encoding in hex): %s" % bin_to_hex(passphrase.encode("utf-8")),
+                    file=sys.stderr,
+                )
+                print(
+                    "As you have a non-ASCII passphrase, it is recommended to keep the "
+                    "UTF-8 encoding in hex together with the passphrase at a safe place.",
+                    file=sys.stderr,
+                )
 
     @classmethod
     def new(cls, allow_empty=False):
@@ -119,17 +125,17 @@ class Passphrase(str):
         if passphrase is not None:
             return passphrase
         for retry in range(1, 11):
-            passphrase = cls.getpass('Enter new passphrase: ')
+            passphrase = cls.getpass("Enter new passphrase: ")
             if allow_empty or passphrase:
-                passphrase2 = cls.getpass('Enter same passphrase again: ')
+                passphrase2 = cls.getpass("Enter same passphrase again: ")
                 if passphrase == passphrase2:
                     cls.verification(passphrase)
-                    logger.info('Remember your passphrase. Your data will be inaccessible without it.')
+                    logger.info("Remember your passphrase. Your data will be inaccessible without it.")
                     return passphrase
                 else:
-                    print('Passphrases do not match', file=sys.stderr)
+                    print("Passphrases do not match", file=sys.stderr)
             else:
-                print('Passphrase must not be blank', file=sys.stderr)
+                print("Passphrase must not be blank", file=sys.stderr)
         else:
             raise PasswordRetriesExceeded
 
diff --git a/src/borg/helpers/process.py b/src/borg/helpers/process.py
index 0cedcb7b7..41aa38815 100644
--- a/src/borg/helpers/process.py
+++ b/src/borg/helpers/process.py
@@ -13,6 +13,7 @@ from .. import __version__
 
 from ..platformflags import is_win32, is_linux, is_freebsd, is_darwin
 from ..logger import create_logger
+
 logger = create_logger()
 
 from ..helpers import EXIT_SUCCESS, EXIT_WARNING, EXIT_SIGNAL_BASE, Error
@@ -21,6 +22,7 @@ from ..helpers import EXIT_SUCCESS, EXIT_WARNING, EXIT_SIGNAL_BASE, Error
 @contextlib.contextmanager
 def _daemonize():
     from ..platform import get_process_id
+
     old_id = get_process_id()
     pid = os.fork()
     if pid:
@@ -30,13 +32,13 @@ def _daemonize():
         except _ExitCodeException as e:
             exit_code = e.exit_code
         finally:
-            logger.debug('Daemonizing: Foreground process (%s, %s, %s) is now dying.' % old_id)
+            logger.debug("Daemonizing: Foreground process (%s, %s, %s) is now dying." % old_id)
             os._exit(exit_code)
     os.setsid()
     pid = os.fork()
     if pid:
         os._exit(0)
-    os.chdir('/')
+    os.chdir("/")
     os.close(0)
     os.close(1)
     fd = os.open(os.devnull, os.O_RDWR)
@@ -78,12 +80,12 @@ def daemonizing(*, timeout=5):
     with _daemonize() as (old_id, new_id):
         if new_id is None:
             # The original / parent process, waiting for a signal to die.
-            logger.debug('Daemonizing: Foreground process (%s, %s, %s) is waiting for background process...' % old_id)
+            logger.debug("Daemonizing: Foreground process (%s, %s, %s) is waiting for background process..." % old_id)
             exit_code = EXIT_SUCCESS
             # Indeed, SIGHUP and SIGTERM handlers should have been set on archiver.run(). Just in case...
-            with signal_handler('SIGINT', raising_signal_handler(KeyboardInterrupt)), \
-                 signal_handler('SIGHUP', raising_signal_handler(SigHup)), \
-                 signal_handler('SIGTERM', raising_signal_handler(SigTerm)):
+            with signal_handler("SIGINT", raising_signal_handler(KeyboardInterrupt)), signal_handler(
+                "SIGHUP", raising_signal_handler(SigHup)
+            ), signal_handler("SIGTERM", raising_signal_handler(SigTerm)):
                 try:
                     if timeout > 0:
                         time.sleep(timeout)
@@ -96,15 +98,17 @@ def daemonizing(*, timeout=5):
                     exit_code = EXIT_WARNING
                 except KeyboardInterrupt:
                     # Manual termination.
-                    logger.debug('Daemonizing: Foreground process (%s, %s, %s) received SIGINT.' % old_id)
+                    logger.debug("Daemonizing: Foreground process (%s, %s, %s) received SIGINT." % old_id)
                     exit_code = EXIT_SIGNAL_BASE + 2
                 except BaseException as e:
                     # Just in case...
-                    logger.warning('Daemonizing: Foreground process received an exception while waiting:\n' +
-                                   ''.join(traceback.format_exception(e.__class__, e, e.__traceback__)))
+                    logger.warning(
+                        "Daemonizing: Foreground process received an exception while waiting:\n"
+                        + "".join(traceback.format_exception(e.__class__, e, e.__traceback__))
+                    )
                     exit_code = EXIT_WARNING
                 else:
-                    logger.warning('Daemonizing: Background process did not respond (timeout). Is it alive?')
+                    logger.warning("Daemonizing: Background process did not respond (timeout). Is it alive?")
                     exit_code = EXIT_WARNING
                 finally:
                     # Don't call with-body, but die immediately!
@@ -113,22 +117,26 @@ def daemonizing(*, timeout=5):
 
         # The background / grandchild process.
         sig_to_foreground = signal.SIGTERM
-        logger.debug('Daemonizing: Background process (%s, %s, %s) is starting...' % new_id)
+        logger.debug("Daemonizing: Background process (%s, %s, %s) is starting..." % new_id)
         try:
             yield old_id, new_id
         except BaseException as e:
             sig_to_foreground = signal.SIGHUP
-            logger.warning('Daemonizing: Background process raised an exception while starting:\n' +
-                           ''.join(traceback.format_exception(e.__class__, e, e.__traceback__)))
+            logger.warning(
+                "Daemonizing: Background process raised an exception while starting:\n"
+                + "".join(traceback.format_exception(e.__class__, e, e.__traceback__))
+            )
             raise e
         else:
-            logger.debug('Daemonizing: Background process (%s, %s, %s) has started.' % new_id)
+            logger.debug("Daemonizing: Background process (%s, %s, %s) has started." % new_id)
         finally:
             try:
                 os.kill(old_id[1], sig_to_foreground)
             except BaseException as e:
-                logger.error('Daemonizing: Trying to kill the foreground process raised an exception:\n' +
-                             ''.join(traceback.format_exception(e.__class__, e, e.__traceback__)))
+                logger.error(
+                    "Daemonizing: Trying to kill the foreground process raised an exception:\n"
+                    + "".join(traceback.format_exception(e.__class__, e, e.__traceback__))
+                )
 
 
 class _ExitCodeException(BaseException):
@@ -187,7 +195,7 @@ class SigIntManager:
         self._sig_int_triggered = False
         self._action_triggered = False
         self._action_done = False
-        self.ctx = signal_handler('SIGINT', self.handler)
+        self.ctx = signal_handler("SIGINT", self.handler)
 
     def __bool__(self):
         # this will be True (and stay True) after the first Ctrl-C/SIGINT
@@ -228,7 +236,7 @@ class SigIntManager:
 sig_int = SigIntManager()
 
 
-def popen_with_error_handling(cmd_line: str, log_prefix='', **kwargs):
+def popen_with_error_handling(cmd_line: str, log_prefix="", **kwargs):
     """
     Handle typical errors raised by subprocess.Popen. Return None if an error occurred,
     otherwise return the Popen object.
@@ -240,27 +248,27 @@ def popen_with_error_handling(cmd_line: str, log_prefix='', **kwargs):
 
     Does not change the exit code.
     """
-    assert not kwargs.get('shell'), 'Sorry pal, shell mode is a no-no'
+    assert not kwargs.get("shell"), "Sorry pal, shell mode is a no-no"
     try:
         command = shlex.split(cmd_line)
         if not command:
-            raise ValueError('an empty command line is not permitted')
+            raise ValueError("an empty command line is not permitted")
     except ValueError as ve:
-        logger.error('%s%s', log_prefix, ve)
+        logger.error("%s%s", log_prefix, ve)
         return
-    logger.debug('%scommand line: %s', log_prefix, command)
+    logger.debug("%scommand line: %s", log_prefix, command)
     try:
         return subprocess.Popen(command, **kwargs)
     except FileNotFoundError:
-        logger.error('%sexecutable not found: %s', log_prefix, command[0])
+        logger.error("%sexecutable not found: %s", log_prefix, command[0])
         return
     except PermissionError:
-        logger.error('%spermission denied: %s', log_prefix, command[0])
+        logger.error("%spermission denied: %s", log_prefix, command[0])
         return
 
 
 def is_terminal(fd=sys.stdout):
-    return hasattr(fd, 'isatty') and fd.isatty() and (not is_win32 or 'ANSICON' in os.environ)
+    return hasattr(fd, "isatty") and fd.isatty() and (not is_win32 or "ANSICON" in os.environ)
 
 
 def prepare_subprocess_env(system, env=None):
@@ -278,8 +286,8 @@ def prepare_subprocess_env(system, env=None):
         # but we do not want that system binaries (like ssh or other) pick up
         # (non-matching) libraries from there.
         # thus we install the original LDLP, before pyinstaller has modified it:
-        lp_key = 'LD_LIBRARY_PATH'
-        lp_orig = env.get(lp_key + '_ORIG')  # pyinstaller >= 20160820 / v3.2.1 has this
+        lp_key = "LD_LIBRARY_PATH"
+        lp_orig = env.get(lp_key + "_ORIG")  # pyinstaller >= 20160820 / v3.2.1 has this
         if lp_orig is not None:
             env[lp_key] = lp_orig
         else:
@@ -292,12 +300,12 @@ def prepare_subprocess_env(system, env=None):
             #    in this case, we must kill LDLP.
             #    We can recognize this via sys.frozen and sys._MEIPASS being set.
             lp = env.get(lp_key)
-            if lp is not None and getattr(sys, 'frozen', False) and hasattr(sys, '_MEIPASS'):
+            if lp is not None and getattr(sys, "frozen", False) and hasattr(sys, "_MEIPASS"):
                 env.pop(lp_key)
     # security: do not give secrets to subprocess
-    env.pop('BORG_PASSPHRASE', None)
+    env.pop("BORG_PASSPHRASE", None)
     # for information, give borg version to the subprocess
-    env['BORG_VERSION'] = __version__
+    env["BORG_VERSION"] = __version__
     return env
 
 
@@ -314,13 +322,15 @@ def create_filter_process(cmd, stream, stream_close, inbound=True):
         # communication with the process is a one-way road, i.e. the process can never block
         # for us to do something while we block on the process for something different.
         if inbound:
-            proc = popen_with_error_handling(cmd, stdout=subprocess.PIPE, stdin=filter_stream,
-                                             log_prefix='filter-process: ', env=env)
+            proc = popen_with_error_handling(
+                cmd, stdout=subprocess.PIPE, stdin=filter_stream, log_prefix="filter-process: ", env=env
+            )
         else:
-            proc = popen_with_error_handling(cmd, stdin=subprocess.PIPE, stdout=filter_stream,
-                                             log_prefix='filter-process: ', env=env)
+            proc = popen_with_error_handling(
+                cmd, stdin=subprocess.PIPE, stdout=filter_stream, log_prefix="filter-process: ", env=env
+            )
         if not proc:
-            raise Error(f'filter {cmd}: process creation failed')
+            raise Error(f"filter {cmd}: process creation failed")
         stream = proc.stdout if inbound else proc.stdin
         # inbound: do not close the pipe (this is the task of the filter process [== writer])
         # outbound: close the pipe, otherwise the filter process would not notice when we are done.
@@ -331,7 +341,7 @@ def create_filter_process(cmd, stream, stream_close, inbound=True):
 
     except Exception:
         # something went wrong with processing the stream by borg
-        logger.debug('Exception, killing the filter...')
+        logger.debug("Exception, killing the filter...")
         if cmd:
             proc.kill()
         borg_succeeded = False
@@ -343,11 +353,11 @@ def create_filter_process(cmd, stream, stream_close, inbound=True):
             stream.close()
 
         if cmd:
-            logger.debug('Done, waiting for filter to die...')
+            logger.debug("Done, waiting for filter to die...")
             rc = proc.wait()
-            logger.debug('filter cmd exited with code %d', rc)
+            logger.debug("filter cmd exited with code %d", rc)
             if filter_stream_close:
                 filter_stream.close()
             if borg_succeeded and rc:
                 # if borg did not succeed, we know that we killed the filter process
-                raise Error('filter %s failed, rc=%d' % (cmd, rc))
+                raise Error("filter %s failed, rc=%d" % (cmd, rc))
diff --git a/src/borg/helpers/progress.py b/src/borg/helpers/progress.py
index 312ff2585..11c45c80b 100644
--- a/src/borg/helpers/progress.py
+++ b/src/borg/helpers/progress.py
@@ -5,6 +5,7 @@ import time
 from shutil import get_terminal_size
 
 from ..logger import create_logger
+
 logger = create_logger()
 
 from .parseformat import ellipsis_truncate
@@ -19,7 +20,7 @@ def justify_to_terminal_size(message):
 
 
 class ProgressIndicatorBase:
-    LOGGER = 'borg.output.progress'
+    LOGGER = "borg.output.progress"
     JSON_TYPE = None
     json = False
 
@@ -43,15 +44,15 @@ class ProgressIndicatorBase:
         if not self.logger.handlers:
             self.handler = logging.StreamHandler(stream=sys.stderr)
             self.handler.setLevel(logging.INFO)
-            logger = logging.getLogger('borg')
+            logger = logging.getLogger("borg")
             # Some special attributes on the borg logger, created by setup_logging
             # But also be able to work without that
             try:
                 formatter = logger.formatter
-                terminator = '\n' if logger.json else '\r'
+                terminator = "\n" if logger.json else "\r"
                 self.json = logger.json
             except AttributeError:
-                terminator = '\r'
+                terminator = "\r"
             else:
                 self.handler.setFormatter(formatter)
             self.handler.terminator = terminator
@@ -79,24 +80,20 @@ class ProgressIndicatorBase:
         assert self.json
         if not self.emit:
             return
-        kwargs.update(dict(
-            operation=self.id,
-            msgid=self.msgid,
-            type=self.JSON_TYPE,
-            finished=finished,
-            time=time.time(),
-        ))
+        kwargs.update(
+            dict(operation=self.id, msgid=self.msgid, type=self.JSON_TYPE, finished=finished, time=time.time())
+        )
         print(json.dumps(kwargs), file=sys.stderr, flush=True)
 
     def finish(self):
         if self.json:
             self.output_json(finished=True)
         else:
-            self.output('')
+            self.output("")
 
 
 class ProgressIndicatorMessage(ProgressIndicatorBase):
-    JSON_TYPE = 'progress_message'
+    JSON_TYPE = "progress_message"
 
     def output(self, msg):
         if self.json:
@@ -106,7 +103,7 @@ class ProgressIndicatorMessage(ProgressIndicatorBase):
 
 
 class ProgressIndicatorPercent(ProgressIndicatorBase):
-    JSON_TYPE = 'progress_percent'
+    JSON_TYPE = "progress_percent"
 
     def __init__(self, total=0, step=5, start=0, msg="%3.0f%%", msgid=None):
         """
@@ -150,7 +147,7 @@ class ProgressIndicatorPercent(ProgressIndicatorBase):
                     # no need to truncate if we're not outputting to a terminal
                     terminal_space = get_terminal_size(fallback=(-1, -1))[0]
                     if terminal_space != -1:
-                        space = terminal_space - len(self.msg % tuple([pct] + info[:-1] + ['']))
+                        space = terminal_space - len(self.msg % tuple([pct] + info[:-1] + [""]))
                         info[-1] = ellipsis_truncate(info[-1], space)
                 return self.output(self.msg % tuple([pct] + info), justify=False, info=info)
 
@@ -193,7 +190,7 @@ class ProgressIndicatorEndless:
             return self.output(self.triggered)
 
     def output(self, triggered):
-        print('.', end='', file=self.file, flush=True)
+        print(".", end="", file=self.file, flush=True)
 
     def finish(self):
         print(file=self.file)
diff --git a/src/borg/helpers/time.py b/src/borg/helpers/time.py
index 8b48076f7..a7170764d 100644
--- a/src/borg/helpers/time.py
+++ b/src/borg/helpers/time.py
@@ -12,7 +12,7 @@ def to_localtime(ts):
 
 def parse_timestamp(timestamp, tzinfo=timezone.utc):
     """Parse a ISO 8601 timestamp string"""
-    fmt = ISO_FORMAT if '.' in timestamp else ISO_FORMAT_NO_USECS
+    fmt = ISO_FORMAT if "." in timestamp else ISO_FORMAT_NO_USECS
     dt = datetime.strptime(timestamp, fmt)
     if tzinfo is not None:
         dt = dt.replace(tzinfo=tzinfo)
@@ -27,11 +27,16 @@ def timestamp(s):
         return datetime.fromtimestamp(ts, tz=timezone.utc)
     except OSError:
         # didn't work, try parsing as timestamp. UTC, no TZ, no microsecs support.
-        for format in ('%Y-%m-%dT%H:%M:%SZ', '%Y-%m-%dT%H:%M:%S+00:00',
-                       '%Y-%m-%dT%H:%M:%S', '%Y-%m-%d %H:%M:%S',
-                       '%Y-%m-%dT%H:%M', '%Y-%m-%d %H:%M',
-                       '%Y-%m-%d', '%Y-%j',
-                       ):
+        for format in (
+            "%Y-%m-%dT%H:%M:%SZ",
+            "%Y-%m-%dT%H:%M:%S+00:00",
+            "%Y-%m-%dT%H:%M:%S",
+            "%Y-%m-%d %H:%M:%S",
+            "%Y-%m-%dT%H:%M",
+            "%Y-%m-%d %H:%M",
+            "%Y-%m-%d",
+            "%Y-%j",
+        ):
             try:
                 return datetime.strptime(s, format).replace(tzinfo=timezone.utc)
             except ValueError:
@@ -54,7 +59,7 @@ if SUPPORT_32BIT_PLATFORMS:
     # subtract last 48h to avoid any issues that could be caused by tz calculations.
     # this is in the year 2038, so it is also less than y9999 (which is a datetime internal limit).
     # msgpack can pack up to uint64.
-    MAX_S = 2**31-1 - 48*3600
+    MAX_S = 2**31 - 1 - 48 * 3600
     MAX_NS = MAX_S * 1000000000
 else:
     # nanosecond timestamps will fit into a signed int64.
@@ -62,7 +67,7 @@ else:
     # this is in the year 2262, so it is also less than y9999 (which is a datetime internal limit).
     # round down to 1e9 multiple, so MAX_NS corresponds precisely to a integer MAX_S.
     # msgpack can pack up to uint64.
-    MAX_NS = (2**63-1 - 48*3600*1000000000) // 1000000000 * 1000000000
+    MAX_NS = (2**63 - 1 - 48 * 3600 * 1000000000) // 1000000000 * 1000000000
     MAX_S = MAX_NS // 1000000000
 
 
@@ -89,11 +94,11 @@ def safe_timestamp(item_timestamp_ns):
     return datetime.fromtimestamp(t_ns / 1e9)
 
 
-def format_time(ts: datetime, format_spec=''):
+def format_time(ts: datetime, format_spec=""):
     """
     Convert *ts* to a human-friendly format with textual weekday.
     """
-    return ts.strftime('%a, %Y-%m-%d %H:%M:%S' if format_spec == '' else format_spec)
+    return ts.strftime("%a, %Y-%m-%d %H:%M:%S" if format_spec == "" else format_spec)
 
 
 def isoformat_time(ts: datetime):
@@ -105,19 +110,18 @@ def isoformat_time(ts: datetime):
 
 
 def format_timedelta(td):
-    """Format timedelta in a human friendly format
-    """
+    """Format timedelta in a human friendly format"""
     ts = td.total_seconds()
     s = ts % 60
     m = int(ts / 60) % 60
     h = int(ts / 3600) % 24
-    txt = '%.2f seconds' % s
+    txt = "%.2f seconds" % s
     if m:
-        txt = '%d minutes %s' % (m, txt)
+        txt = "%d minutes %s" % (m, txt)
     if h:
-        txt = '%d hours %s' % (h, txt)
+        txt = "%d hours %s" % (h, txt)
     if td.days:
-        txt = '%d days %s' % (td.days, txt)
+        txt = "%d days %s" % (td.days, txt)
     return txt
 
 
@@ -131,7 +135,7 @@ class OutputTimestamp:
         return format_time(self.ts, format_spec=format_spec)
 
     def __str__(self):
-        return f'{self}'
+        return f"{self}"
 
     def isoformat(self):
         return isoformat_time(self.ts)
diff --git a/src/borg/helpers/yes.py b/src/borg/helpers/yes.py
index 042abcfc8..745b06a51 100644
--- a/src/borg/helpers/yes.py
+++ b/src/borg/helpers/yes.py
@@ -4,16 +4,30 @@ import os
 import os.path
 import sys
 
-FALSISH = ('No', 'NO', 'no', 'N', 'n', '0', )
-TRUISH = ('Yes', 'YES', 'yes', 'Y', 'y', '1', )
-DEFAULTISH = ('Default', 'DEFAULT', 'default', 'D', 'd', '', )
+FALSISH = ("No", "NO", "no", "N", "n", "0")
+TRUISH = ("Yes", "YES", "yes", "Y", "y", "1")
+DEFAULTISH = ("Default", "DEFAULT", "default", "D", "d", "")
 
 
-def yes(msg=None, false_msg=None, true_msg=None, default_msg=None,
-        retry_msg=None, invalid_msg=None, env_msg='{} (from {})',
-        falsish=FALSISH, truish=TRUISH, defaultish=DEFAULTISH,
-        default=False, retry=True, env_var_override=None, ofile=None, input=input, prompt=True,
-        msgid=None):
+def yes(
+    msg=None,
+    false_msg=None,
+    true_msg=None,
+    default_msg=None,
+    retry_msg=None,
+    invalid_msg=None,
+    env_msg="{} (from {})",
+    falsish=FALSISH,
+    truish=TRUISH,
+    defaultish=DEFAULTISH,
+    default=False,
+    retry=True,
+    env_var_override=None,
+    ofile=None,
+    input=input,
+    prompt=True,
+    msgid=None,
+):
     """Output <msg> (usually a question) and let user input an answer.
     Qualifies the answer according to falsish, truish and defaultish as True, False or <default>.
     If it didn't qualify and retry is False (no retries wanted), return the default [which
@@ -43,18 +57,15 @@ def yes(msg=None, false_msg=None, true_msg=None, default_msg=None,
     :param input: input function [input from builtins]
     :return: boolean answer value, True or False
     """
+
     def output(msg, msg_type, is_prompt=False, **kwargs):
-        json_output = getattr(logging.getLogger('borg'), 'json', False)
+        json_output = getattr(logging.getLogger("borg"), "json", False)
         if json_output:
-            kwargs.update(dict(
-                type='question_%s' % msg_type,
-                msgid=msgid,
-                message=msg,
-            ))
+            kwargs.update(dict(type="question_%s" % msg_type, msgid=msgid, message=msg))
             print(json.dumps(kwargs), file=sys.stderr)
         else:
             if is_prompt:
-                print(msg, file=ofile, end='', flush=True)
+                print(msg, file=ofile, end="", flush=True)
             else:
                 print(msg, file=ofile)
 
@@ -66,13 +77,13 @@ def yes(msg=None, false_msg=None, true_msg=None, default_msg=None,
     if default not in (True, False):
         raise ValueError("invalid default value, must be True or False")
     if msg:
-        output(msg, 'prompt', is_prompt=True)
+        output(msg, "prompt", is_prompt=True)
     while True:
         answer = None
         if env_var_override:
             answer = os.environ.get(env_var_override)
             if answer is not None and env_msg:
-                output(env_msg.format(answer, env_var_override), 'env_answer', env_var=env_var_override)
+                output(env_msg.format(answer, env_var_override), "env_answer", env_var=env_var_override)
         if answer is None:
             if not prompt:
                 return default
@@ -83,22 +94,22 @@ def yes(msg=None, false_msg=None, true_msg=None, default_msg=None,
                 answer = truish[0] if default else falsish[0]
         if answer in defaultish:
             if default_msg:
-                output(default_msg, 'accepted_default')
+                output(default_msg, "accepted_default")
             return default
         if answer in truish:
             if true_msg:
-                output(true_msg, 'accepted_true')
+                output(true_msg, "accepted_true")
             return True
         if answer in falsish:
             if false_msg:
-                output(false_msg, 'accepted_false')
+                output(false_msg, "accepted_false")
             return False
         # if we get here, the answer was invalid
         if invalid_msg:
-            output(invalid_msg, 'invalid_answer')
+            output(invalid_msg, "invalid_answer")
         if not retry:
             return default
         if retry_msg:
-            output(retry_msg, 'prompt_retry', is_prompt=True)
+            output(retry_msg, "prompt_retry", is_prompt=True)
         # in case we used an environment variable and it gave an invalid answer, do not use it again:
         env_var_override = None
diff --git a/src/borg/locking.py b/src/borg/locking.py
index ecd6d27ca..e7f656915 100644
--- a/src/borg/locking.py
+++ b/src/borg/locking.py
@@ -8,8 +8,8 @@ from . import platform
 from .helpers import Error, ErrorWithTraceback
 from .logger import create_logger
 
-ADD, REMOVE = 'add', 'remove'
-SHARED, EXCLUSIVE = 'shared', 'exclusive'
+ADD, REMOVE = "add", "remove"
+SHARED, EXCLUSIVE = "shared", "exclusive"
 
 logger = create_logger(__name__)
 
@@ -20,6 +20,7 @@ class TimeoutTimer:
     It can also compute and optionally execute a reasonable sleep time (e.g. to avoid
     polling too often or to support thread/process rescheduling).
     """
+
     def __init__(self, timeout=None, sleep=None):
         """
         Initialize a timer.
@@ -43,8 +44,8 @@ class TimeoutTimer:
 
     def __repr__(self):
         return "<{}: start={!r} end={!r} timeout={!r} sleep={!r}>".format(
-            self.__class__.__name__, self.start_time, self.end_time,
-            self.timeout_interval, self.sleep_interval)
+            self.__class__.__name__, self.start_time, self.end_time, self.timeout_interval, self.sleep_interval
+        )
 
     def start(self):
         self.start_time = time.time()
@@ -102,6 +103,7 @@ class ExclusiveLock:
     This makes sure the lock is released again if the block is left, no
     matter how (e.g. if an exception occurred).
     """
+
     def __init__(self, path, timeout=None, sleep=None, id=None):
         self.timeout = timeout
         self.sleep = sleep
@@ -129,7 +131,7 @@ class ExclusiveLock:
         unique_base_name = os.path.basename(self.unique_name)
         temp_path = None
         try:
-            temp_path = tempfile.mkdtemp(".tmp", base_name + '.', parent_path)
+            temp_path = tempfile.mkdtemp(".tmp", base_name + ".", parent_path)
             temp_unique_name = os.path.join(temp_path, unique_base_name)
             with open(temp_unique_name, "wb"):
                 pass
@@ -192,8 +194,8 @@ class ExclusiveLock:
         else:
             for name in names:
                 try:
-                    host_pid, thread_str = name.rsplit('-', 1)
-                    host, pid_str = host_pid.rsplit('.', 1)
+                    host_pid, thread_str = name.rsplit("-", 1)
+                    host, pid_str = host_pid.rsplit(".", 1)
                     pid = int(pid_str)
                     thread = int(thread_str)
                 except ValueError:
@@ -207,17 +209,19 @@ class ExclusiveLock:
                 if not self.kill_stale_locks:
                     if not self.stale_warning_printed:
                         # Log this at warning level to hint the user at the ability
-                        logger.warning("Found stale lock %s, but not deleting because self.kill_stale_locks = False.", name)
+                        logger.warning(
+                            "Found stale lock %s, but not deleting because self.kill_stale_locks = False.", name
+                        )
                         self.stale_warning_printed = True
                     return False
 
                 try:
                     os.unlink(os.path.join(self.path, name))
-                    logger.warning('Killed stale lock %s.', name)
+                    logger.warning("Killed stale lock %s.", name)
                 except OSError as err:
                     if not self.stale_warning_printed:
                         # This error will bubble up and likely result in locking failure
-                        logger.error('Found stale lock %s, but cannot delete due to %s', name, str(err))
+                        logger.error("Found stale lock %s, but cannot delete due to %s", name, str(err))
                         self.stale_warning_printed = True
                     return False
 
@@ -228,7 +232,7 @@ class ExclusiveLock:
                 # Directory is not empty or doesn't exist any more = we lost the race to somebody else--which is ok.
                 return False
             # EACCES or EIO or ... = we cannot operate anyway
-            logger.error('Failed to remove lock dir: %s', str(err))
+            logger.error("Failed to remove lock dir: %s", str(err))
             return False
 
         return True
@@ -257,6 +261,7 @@ class LockRoster:
     Note: you usually should call the methods with an exclusive lock held,
     to avoid conflicting access by multiple threads/processes/machines.
     """
+
     def __init__(self, path, id=None):
         self.path = path
         self.id = id or platform.get_process_id()
@@ -279,8 +284,9 @@ class LockRoster:
                         if platform.process_alive(host, pid, thread):
                             elements.add((host, pid, thread))
                         else:
-                            logger.warning('Removed stale %s roster lock for host %s pid %d thread %d.',
-                                           key, host, pid, thread)
+                            logger.warning(
+                                "Removed stale %s roster lock for host %s pid %d thread %d.", key, host, pid, thread
+                            )
                     data[key] = list(elements)
         except (FileNotFoundError, ValueError):
             # no or corrupt/empty roster file?
@@ -315,7 +321,7 @@ class LockRoster:
         elif op == REMOVE:
             elements.remove(self.id)
         else:
-            raise ValueError('Unknown LockRoster op %r' % op)
+            raise ValueError("Unknown LockRoster op %r" % op)
         roster[key] = list(list(e) for e in elements)
         self.save(roster)
 
@@ -354,6 +360,7 @@ class Lock:
     This makes sure the lock is released again if the block is left, no
     matter how (e.g. if an exception occurred).
     """
+
     def __init__(self, path, exclusive=False, sleep=None, timeout=None, id=None):
         self.path = path
         self.is_exclusive = exclusive
@@ -361,11 +368,11 @@ class Lock:
         self.timeout = timeout
         self.id = id or platform.get_process_id()
         # globally keeping track of shared and exclusive lockers:
-        self._roster = LockRoster(path + '.roster', id=id)
+        self._roster = LockRoster(path + ".roster", id=id)
         # an exclusive lock, used for:
         # - holding while doing roster queries / updates
         # - holding while the Lock itself is exclusive
-        self._lock = ExclusiveLock(path + '.exclusive', id=id, timeout=timeout)
+        self._lock = ExclusiveLock(path + ".exclusive", id=id, timeout=timeout)
 
     def __enter__(self):
         return self.acquire()
diff --git a/src/borg/logger.py b/src/borg/logger.py
index b24eb7711..492b90a27 100644
--- a/src/borg/logger.py
+++ b/src/borg/logger.py
@@ -53,7 +53,7 @@ def _log_warning(message, category, filename, lineno, file=None, line=None):
     logger.warning(msg)
 
 
-def setup_logging(stream=None, conf_fname=None, env_var='BORG_LOGGING_CONF', level='info', is_serve=False, json=False):
+def setup_logging(stream=None, conf_fname=None, env_var="BORG_LOGGING_CONF", level="info", is_serve=False, json=False):
     """setup logging module according to the arguments provided
 
     if conf_fname is given (or the config file name can be determined via
@@ -80,7 +80,7 @@ def setup_logging(stream=None, conf_fname=None, env_var='BORG_LOGGING_CONF', lev
                 logging.config.fileConfig(f)
             configured = True
             logger = logging.getLogger(__name__)
-            borg_logger = logging.getLogger('borg')
+            borg_logger = logging.getLogger("borg")
             borg_logger.json = json
             logger.debug(f'using logging configuration read from "{conf_fname}"')
             warnings.showwarning = _log_warning
@@ -88,15 +88,15 @@ def setup_logging(stream=None, conf_fname=None, env_var='BORG_LOGGING_CONF', lev
         except Exception as err:  # XXX be more precise
             err_msg = str(err)
     # if we did not / not successfully load a logging configuration, fallback to this:
-    logger = logging.getLogger('')
+    logger = logging.getLogger("")
     handler = logging.StreamHandler(stream)
     if is_serve and not json:
-        fmt = '$LOG %(levelname)s %(name)s Remote: %(message)s'
+        fmt = "$LOG %(levelname)s %(name)s Remote: %(message)s"
     else:
-        fmt = '%(message)s'
+        fmt = "%(message)s"
     formatter = JsonFormatter(fmt) if json else logging.Formatter(fmt)
     handler.setFormatter(formatter)
-    borg_logger = logging.getLogger('borg')
+    borg_logger = logging.getLogger("borg")
     borg_logger.formatter = formatter
     borg_logger.json = json
     if configured and logger.handlers:
@@ -111,7 +111,7 @@ def setup_logging(stream=None, conf_fname=None, env_var='BORG_LOGGING_CONF', lev
     logger = logging.getLogger(__name__)
     if err_msg:
         logger.warning(f'setup_logging for "{conf_fname}" failed with "{err_msg}".')
-    logger.debug('using builtin fallback logging configuration')
+    logger.debug("using builtin fallback logging configuration")
     warnings.showwarning = _log_warning
     return handler
 
@@ -151,6 +151,7 @@ def create_logger(name=None):
     be careful not to call any logger methods before the setup_logging() call.
     If you try, you'll get an exception.
     """
+
     class LazyLogger:
         def __init__(self, name=None):
             self.__name = name or find_parent_module()
@@ -162,49 +163,49 @@ def create_logger(name=None):
                 if not configured:
                     raise Exception("tried to call a logger before setup_logging() was called")
                 self.__real_logger = logging.getLogger(self.__name)
-                if self.__name.startswith('borg.debug.') and self.__real_logger.level == logging.NOTSET:
-                    self.__real_logger.setLevel('WARNING')
+                if self.__name.startswith("borg.debug.") and self.__real_logger.level == logging.NOTSET:
+                    self.__real_logger.setLevel("WARNING")
             return self.__real_logger
 
         def getChild(self, suffix):
-            return LazyLogger(self.__name + '.' + suffix)
+            return LazyLogger(self.__name + "." + suffix)
 
         def setLevel(self, *args, **kw):
             return self.__logger.setLevel(*args, **kw)
 
         def log(self, *args, **kw):
-            if 'msgid' in kw:
-                kw.setdefault('extra', {})['msgid'] = kw.pop('msgid')
+            if "msgid" in kw:
+                kw.setdefault("extra", {})["msgid"] = kw.pop("msgid")
             return self.__logger.log(*args, **kw)
 
         def exception(self, *args, **kw):
-            if 'msgid' in kw:
-                kw.setdefault('extra', {})['msgid'] = kw.pop('msgid')
+            if "msgid" in kw:
+                kw.setdefault("extra", {})["msgid"] = kw.pop("msgid")
             return self.__logger.exception(*args, **kw)
 
         def debug(self, *args, **kw):
-            if 'msgid' in kw:
-                kw.setdefault('extra', {})['msgid'] = kw.pop('msgid')
+            if "msgid" in kw:
+                kw.setdefault("extra", {})["msgid"] = kw.pop("msgid")
             return self.__logger.debug(*args, **kw)
 
         def info(self, *args, **kw):
-            if 'msgid' in kw:
-                kw.setdefault('extra', {})['msgid'] = kw.pop('msgid')
+            if "msgid" in kw:
+                kw.setdefault("extra", {})["msgid"] = kw.pop("msgid")
             return self.__logger.info(*args, **kw)
 
         def warning(self, *args, **kw):
-            if 'msgid' in kw:
-                kw.setdefault('extra', {})['msgid'] = kw.pop('msgid')
+            if "msgid" in kw:
+                kw.setdefault("extra", {})["msgid"] = kw.pop("msgid")
             return self.__logger.warning(*args, **kw)
 
         def error(self, *args, **kw):
-            if 'msgid' in kw:
-                kw.setdefault('extra', {})['msgid'] = kw.pop('msgid')
+            if "msgid" in kw:
+                kw.setdefault("extra", {})["msgid"] = kw.pop("msgid")
             return self.__logger.error(*args, **kw)
 
         def critical(self, *args, **kw):
-            if 'msgid' in kw:
-                kw.setdefault('extra', {})['msgid'] = kw.pop('msgid')
+            if "msgid" in kw:
+                kw.setdefault("extra", {})["msgid"] = kw.pop("msgid")
             return self.__logger.critical(*args, **kw)
 
     return LazyLogger(name)
@@ -212,11 +213,11 @@ def create_logger(name=None):
 
 class JsonFormatter(logging.Formatter):
     RECORD_ATTRIBUTES = (
-        'levelname',
-        'name',
-        'message',
+        "levelname",
+        "name",
+        "message",
         # msgid is an attribute we made up in Borg to expose a non-changing handle for log messages
-        'msgid',
+        "msgid",
     )
 
     # Other attributes that are not very useful but do exist:
@@ -229,12 +230,7 @@ class JsonFormatter(logging.Formatter):
 
     def format(self, record):
         super().format(record)
-        data = {
-            'type': 'log_message',
-            'time': record.created,
-            'message': '',
-            'levelname': 'CRITICAL',
-        }
+        data = {"type": "log_message", "time": record.created, "message": "", "levelname": "CRITICAL"}
         for attr in self.RECORD_ATTRIBUTES:
             value = getattr(record, attr, None)
             if value:
diff --git a/src/borg/lrucache.py b/src/borg/lrucache.py
index 4f7f1f829..097fe4c52 100644
--- a/src/borg/lrucache.py
+++ b/src/borg/lrucache.py
@@ -10,8 +10,8 @@ class LRUCache:
 
     def __setitem__(self, key, value):
         assert key not in self._cache, (
-            "Unexpected attempt to replace a cached item,"
-            " without first deleting the old item.")
+            "Unexpected attempt to replace a cached item," " without first deleting the old item."
+        )
         self._lru.append(key)
         while len(self._lru) > self._capacity:
             del self[self._lru[0]]
diff --git a/src/borg/nanorst.py b/src/borg/nanorst.py
index 5700a0b3c..71d9e9470 100644
--- a/src/borg/nanorst.py
+++ b/src/borg/nanorst.py
@@ -11,18 +11,18 @@ class TextPecker:
 
     def read(self, n):
         self.i += n
-        return self.str[self.i - n:self.i]
+        return self.str[self.i - n : self.i]
 
     def peek(self, n):
         if n >= 0:
-            return self.str[self.i:self.i + n]
+            return self.str[self.i : self.i + n]
         else:
-            return self.str[self.i + n - 1:self.i - 1]
+            return self.str[self.i + n - 1 : self.i - 1]
 
     def peekline(self):
-        out = ''
+        out = ""
         i = self.i
-        while i < len(self.str) and self.str[i] != '\n':
+        while i < len(self.str) and self.str[i] != "\n":
             out += self.str[i]
             i += 1
         return out
@@ -34,18 +34,18 @@ class TextPecker:
 
 
 def process_directive(directive, arguments, out, state_hook):
-    if directive == 'container' and arguments == 'experimental':
-        state_hook('text', '**', out)
-        out.write('++ Experimental ++')
-        state_hook('**', 'text', out)
+    if directive == "container" and arguments == "experimental":
+        state_hook("text", "**", out)
+        out.write("++ Experimental ++")
+        state_hook("**", "text", out)
     else:
-        state_hook('text', '**', out)
+        state_hook("text", "**", out)
         out.write(directive.title())
-        out.write(':\n')
-        state_hook('**', 'text', out)
+        out.write(":\n")
+        state_hook("**", "text", out)
         if arguments:
             out.write(arguments)
-            out.write('\n')
+            out.write("\n")
 
 
 def rst_to_text(text, state_hook=None, references=None):
@@ -58,12 +58,12 @@ def rst_to_text(text, state_hook=None, references=None):
     """
     state_hook = state_hook or (lambda old_state, new_state, out: None)
     references = references or {}
-    state = 'text'
-    inline_mode = 'replace'
+    state = "text"
+    inline_mode = "replace"
     text = TextPecker(text)
     out = io.StringIO()
 
-    inline_single = ('*', '`')
+    inline_single = ("*", "`")
 
     while True:
         char = text.read(1)
@@ -71,81 +71,83 @@ def rst_to_text(text, state_hook=None, references=None):
             break
         next = text.peek(1)  # type: str
 
-        if state == 'text':
-            if char == '\\' and text.peek(1) in inline_single:
+        if state == "text":
+            if char == "\\" and text.peek(1) in inline_single:
                 continue
-            if text.peek(-1) != '\\':
+            if text.peek(-1) != "\\":
                 if char in inline_single and next != char:
                     state_hook(state, char, out)
                     state = char
                     continue
-                if char == next == '*':
-                    state_hook(state, '**', out)
-                    state = '**'
+                if char == next == "*":
+                    state_hook(state, "**", out)
+                    state = "**"
                     text.read(1)
                     continue
-                if char == next == '`':
-                    state_hook(state, '``', out)
-                    state = '``'
+                if char == next == "`":
+                    state_hook(state, "``", out)
+                    state = "``"
                     text.read(1)
                     continue
-                if text.peek(-1).isspace() and char == ':' and text.peek(5) == 'ref:`':
+                if text.peek(-1).isspace() and char == ":" and text.peek(5) == "ref:`":
                     # translate reference
                     text.read(5)
-                    ref = ''
+                    ref = ""
                     while True:
                         char = text.peek(1)
-                        if char == '`':
+                        if char == "`":
                             text.read(1)
                             break
-                        if char == '\n':
+                        if char == "\n":
                             text.read(1)
                             continue  # merge line breaks in :ref:`...\n...`
                         ref += text.read(1)
                     try:
                         out.write(references[ref])
                     except KeyError:
-                        raise ValueError("Undefined reference in Archiver help: %r — please add reference "
-                                         "substitution to 'rst_plain_text_references'" % ref)
+                        raise ValueError(
+                            "Undefined reference in Archiver help: %r — please add reference "
+                            "substitution to 'rst_plain_text_references'" % ref
+                        )
                     continue
-                if char == ':' and text.peek(2) == ':\n':  # End of line code block
+                if char == ":" and text.peek(2) == ":\n":  # End of line code block
                     text.read(2)
-                    state_hook(state, 'code-block', out)
-                    state = 'code-block'
-                    out.write(':\n')
+                    state_hook(state, "code-block", out)
+                    state = "code-block"
+                    out.write(":\n")
                     continue
-            if text.peek(-2) in ('\n\n', '') and char == next == '.':
+            if text.peek(-2) in ("\n\n", "") and char == next == ".":
                 text.read(2)
-                directive, is_directive, arguments = text.readline().partition('::')
+                directive, is_directive, arguments = text.readline().partition("::")
                 text.read(1)
                 if not is_directive:
                     # partition: if the separator is not in the text, the leftmost output is the entire input
-                    if directive == 'nanorst: inline-fill':
-                        inline_mode = 'fill'
-                    elif directive == 'nanorst: inline-replace':
-                        inline_mode = 'replace'
+                    if directive == "nanorst: inline-fill":
+                        inline_mode = "fill"
+                    elif directive == "nanorst: inline-replace":
+                        inline_mode = "replace"
                     continue
                 process_directive(directive, arguments.strip(), out, state_hook)
                 continue
         if state in inline_single and char == state:
-            state_hook(state, 'text', out)
-            state = 'text'
-            if inline_mode == 'fill':
-                out.write(2 * ' ')
+            state_hook(state, "text", out)
+            state = "text"
+            if inline_mode == "fill":
+                out.write(2 * " ")
             continue
-        if state == '``' and char == next == '`':
-            state_hook(state, 'text', out)
-            state = 'text'
+        if state == "``" and char == next == "`":
+            state_hook(state, "text", out)
+            state = "text"
             text.read(1)
-            if inline_mode == 'fill':
-                out.write(4 * ' ')
+            if inline_mode == "fill":
+                out.write(4 * " ")
             continue
-        if state == '**' and char == next == '*':
-            state_hook(state, 'text', out)
-            state = 'text'
+        if state == "**" and char == next == "*":
+            state_hook(state, "text", out)
+            state = "text"
             text.read(1)
             continue
-        if state == 'code-block' and char == next == '\n' and text.peek(5)[1:] != '    ':
+        if state == "code-block" and char == next == "\n" and text.peek(5)[1:] != "    ":
             # Foo::
             #
             #     *stuff* *code* *ignore .. all markup*
@@ -153,11 +155,11 @@ def rst_to_text(text, state_hook=None, references=None):
             #     More arcane stuff
             #
             # Regular text...
-            state_hook(state, 'text', out)
-            state = 'text'
+            state_hook(state, "text", out)
+            state = "text"
         out.write(char)
 
-    assert state == 'text', 'Invalid final state %r (This usually indicates unmatched */**)' % state
+    assert state == "text", "Invalid final state %r (This usually indicates unmatched */**)" % state
     return out.getvalue()
 
 
@@ -191,12 +193,12 @@ class RstToTextLazy:
 
 
 def ansi_escapes(old_state, new_state, out):
-    if old_state == 'text' and new_state in ('*', '`', '``'):
-        out.write('\033[4m')
-    if old_state == 'text' and new_state == '**':
-        out.write('\033[1m')
-    if old_state in ('*', '`', '``', '**') and new_state == 'text':
-        out.write('\033[0m')
+    if old_state == "text" and new_state in ("*", "`", "``"):
+        out.write("\033[4m")
+    if old_state == "text" and new_state == "**":
+        out.write("\033[1m")
+    if old_state in ("*", "`", "``", "**") and new_state == "text":
+        out.write("\033[0m")
 
 
 def rst_to_terminal(rst, references=None, destination=sys.stdout):
diff --git a/src/borg/patterns.py b/src/borg/patterns.py
index 49668ef2b..749430190 100644
--- a/src/borg/patterns.py
+++ b/src/borg/patterns.py
@@ -75,6 +75,7 @@ class PatternMatcher:
     *fallback* is a boolean value that *match()* returns if no matching patterns are found.
 
     """
+
     def __init__(self, fallback=None):
         self._items = []
 
@@ -96,18 +97,13 @@ class PatternMatcher:
         self.include_patterns = []
 
         # TODO: move this info to parse_inclexcl_command and store in PatternBase subclass?
-        self.is_include_cmd = {
-            IECommand.Exclude: False,
-            IECommand.ExcludeNoRecurse: False,
-            IECommand.Include: True
-        }
+        self.is_include_cmd = {IECommand.Exclude: False, IECommand.ExcludeNoRecurse: False, IECommand.Include: True}
 
     def empty(self):
         return not len(self._items) and not len(self._path_full_patterns)
 
     def _add(self, pattern, cmd):
-        """*cmd* is an IECommand value.
-        """
+        """*cmd* is an IECommand value."""
         if isinstance(pattern, PathFullPattern):
             key = pattern.pattern  # full, normalized path
             self._path_full_patterns[key] = cmd
@@ -123,8 +119,7 @@ class PatternMatcher:
             self._add(pattern, cmd)
 
     def add_includepaths(self, include_paths):
-        """Used to add inclusion-paths from args.paths (from commandline).
-        """
+        """Used to add inclusion-paths from args.paths (from commandline)."""
         include_patterns = [parse_pattern(p, PathPrefixPattern) for p in include_paths]
         self.add(include_patterns, IECommand.Include)
         self.fallback = not include_patterns
@@ -135,8 +130,7 @@ class PatternMatcher:
         return [p for p in self.include_patterns if p.match_count == 0]
 
     def add_inclexcl(self, patterns):
-        """Add list of patterns (of type CmdTuple) to internal list.
-        """
+        """Add list of patterns (of type CmdTuple) to internal list."""
         for pattern, cmd in patterns:
             self._add(pattern, cmd)
 
@@ -172,12 +166,12 @@ def normalize_path(path):
     """normalize paths for MacOS (but do nothing on other platforms)"""
     # HFS+ converts paths to a canonical form, so users shouldn't be required to enter an exact match.
     # Windows and Unix filesystems allow different forms, so users always have to enter an exact match.
-    return unicodedata.normalize('NFD', path) if sys.platform == 'darwin' else path
+    return unicodedata.normalize("NFD", path) if sys.platform == "darwin" else path
 
 
 class PatternBase:
-    """Shared logic for inclusion/exclusion patterns.
-    """
+    """Shared logic for inclusion/exclusion patterns."""
+
     PREFIX = NotImplemented
 
     def __init__(self, pattern, recurse_dir=False):
@@ -201,7 +195,7 @@ class PatternBase:
         return matches
 
     def __repr__(self):
-        return f'{type(self)}({self.pattern})'
+        return f"{type(self)}({self.pattern})"
 
     def __str__(self):
         return self.pattern_orig
@@ -216,6 +210,7 @@ class PatternBase:
 
 class PathFullPattern(PatternBase):
     """Full match of a path."""
+
     PREFIX = "pf"
 
     def _prepare(self, pattern):
@@ -236,6 +231,7 @@ class PathPrefixPattern(PatternBase):
     If a directory is specified, all paths that start with that
     path match as well.  A trailing slash makes no difference.
     """
+
     PREFIX = "pp"
 
     def _prepare(self, pattern):
@@ -251,13 +247,14 @@ class FnmatchPattern(PatternBase):
     """Shell glob patterns to exclude.  A trailing slash means to
     exclude the contents of a directory, but not the directory itself.
     """
+
     PREFIX = "fm"
 
     def _prepare(self, pattern):
         if pattern.endswith(os.path.sep):
-            pattern = os.path.normpath(pattern).rstrip(os.path.sep) + os.path.sep + '*' + os.path.sep
+            pattern = os.path.normpath(pattern).rstrip(os.path.sep) + os.path.sep + "*" + os.path.sep
         else:
-            pattern = os.path.normpath(pattern) + os.path.sep + '*'
+            pattern = os.path.normpath(pattern) + os.path.sep + "*"
 
         self.pattern = pattern.lstrip(os.path.sep)  # sep at beginning is removed
 
@@ -266,13 +263,14 @@ class FnmatchPattern(PatternBase):
         self.regex = re.compile(fnmatch.translate(self.pattern))
 
     def _match(self, path):
-        return (self.regex.match(path + os.path.sep) is not None)
+        return self.regex.match(path + os.path.sep) is not None
 
 
 class ShellPattern(PatternBase):
     """Shell glob patterns to exclude.  A trailing slash means to
     exclude the contents of a directory, but not the directory itself.
     """
+
     PREFIX = "sh"
 
     def _prepare(self, pattern):
@@ -287,12 +285,12 @@ class ShellPattern(PatternBase):
         self.regex = re.compile(shellpattern.translate(self.pattern))
 
     def _match(self, path):
-        return (self.regex.match(path + os.path.sep) is not None)
+        return self.regex.match(path + os.path.sep) is not None
 
 
 class RegexPattern(PatternBase):
-    """Regular expression to exclude.
-    """
+    """Regular expression to exclude."""
+
     PREFIX = "re"
 
     def _prepare(self, pattern):
@@ -301,28 +299,22 @@ class RegexPattern(PatternBase):
 
     def _match(self, path):
         # Normalize path separators
-        if os.path.sep != '/':
-            path = path.replace(os.path.sep, '/')
+        if os.path.sep != "/":
+            path = path.replace(os.path.sep, "/")
 
-        return (self.regex.search(path) is not None)
+        return self.regex.search(path) is not None
 
 
-_PATTERN_CLASSES = {
-    FnmatchPattern,
-    PathFullPattern,
-    PathPrefixPattern,
-    RegexPattern,
-    ShellPattern,
-}
+_PATTERN_CLASSES = {FnmatchPattern, PathFullPattern, PathPrefixPattern, RegexPattern, ShellPattern}
 
 _PATTERN_CLASS_BY_PREFIX = {i.PREFIX: i for i in _PATTERN_CLASSES}
 
-CmdTuple = namedtuple('CmdTuple', 'val cmd')
+CmdTuple = namedtuple("CmdTuple", "val cmd")
 
 
 class IECommand(Enum):
-    """A command that an InclExcl file line can represent.
-    """
+    """A command that an InclExcl file line can represent."""
+
     RootPath = 1
     PatternStyle = 2
     Include = 3
@@ -343,9 +335,7 @@ def get_pattern_class(prefix):
 
 
 def parse_pattern(pattern, fallback=FnmatchPattern, recurse_dir=True):
-    """Read pattern from string and return an instance of the appropriate implementation class.
-
-    """
+    """Read pattern from string and return an instance of the appropriate implementation class."""
     if len(pattern) > 2 and pattern[2] == ":" and pattern[:2].isalnum():
         (style, pattern) = (pattern[:2], pattern[3:])
         cls = get_pattern_class(style)
@@ -355,8 +345,7 @@ def parse_pattern(pattern, fallback=FnmatchPattern, recurse_dir=True):
 
 
 def parse_exclude_pattern(pattern_str, fallback=FnmatchPattern):
-    """Read pattern from string and return an instance of the appropriate implementation class.
-    """
+    """Read pattern from string and return an instance of the appropriate implementation class."""
     epattern_obj = parse_pattern(pattern_str, fallback, recurse_dir=False)
     return CmdTuple(epattern_obj, IECommand.ExcludeNoRecurse)
 
@@ -365,21 +354,20 @@ def parse_inclexcl_command(cmd_line_str, fallback=ShellPattern):
     """Read a --patterns-from command from string and return a CmdTuple object."""
 
     cmd_prefix_map = {
-        '-': IECommand.Exclude,
-        '!': IECommand.ExcludeNoRecurse,
-        '+': IECommand.Include,
-        'R': IECommand.RootPath,
-        'r': IECommand.RootPath,
-        'P': IECommand.PatternStyle,
-        'p': IECommand.PatternStyle,
+        "-": IECommand.Exclude,
+        "!": IECommand.ExcludeNoRecurse,
+        "+": IECommand.Include,
+        "R": IECommand.RootPath,
+        "r": IECommand.RootPath,
+        "P": IECommand.PatternStyle,
+        "p": IECommand.PatternStyle,
     }
     if not cmd_line_str:
         raise argparse.ArgumentTypeError("A pattern/command must not be empty.")
 
     cmd = cmd_prefix_map.get(cmd_line_str[0])
     if cmd is None:
-        raise argparse.ArgumentTypeError("A pattern/command must start with anyone of: %s" %
-                                         ', '.join(cmd_prefix_map))
+        raise argparse.ArgumentTypeError("A pattern/command must start with anyone of: %s" % ", ".join(cmd_prefix_map))
 
     # remaining text on command-line following the command character
     remainder_str = cmd_line_str[1:].lstrip()
diff --git a/src/borg/platform/__init__.py b/src/borg/platform/__init__.py
index 98f926230..6692960fe 100644
--- a/src/borg/platform/__init__.py
+++ b/src/borg/platform/__init__.py
@@ -17,6 +17,7 @@ OS_API_VERSION = API_VERSION
 
 if not is_win32:
     from .posix import process_alive, local_pid_alive
+
     # posix swidth implementation works for: linux, freebsd, darwin, openindiana, cygwin
     from .posix import swidth
     from .posix import get_errno
diff --git a/src/borg/platform/base.py b/src/borg/platform/base.py
index d6f2aae8f..15b778729 100644
--- a/src/borg/platform/base.py
+++ b/src/borg/platform/base.py
@@ -20,9 +20,9 @@ platform API: that way platform APIs provided by the platform-specific support m
 are correctly composed into the base functionality.
 """
 
-API_VERSION = '1.2_05'
+API_VERSION = "1.2_05"
 
-fdatasync = getattr(os, 'fdatasync', os.fsync)
+fdatasync = getattr(os, "fdatasync", os.fsync)
 
 from .xattr import ENOATTR
 
@@ -86,14 +86,16 @@ try:
 
     def set_flags(path, bsd_flags, fd=None):
         lchflags(path, bsd_flags)
+
 except ImportError:
+
     def set_flags(path, bsd_flags, fd=None):
         pass
 
 
 def get_flags(path, st, fd=None):
     """Return BSD-style file flags for path or stat without following symlinks."""
-    return getattr(st, 'st_flags', 0)
+    return getattr(st, "st_flags", 0)
 
 
 def sync_dir(path):
@@ -114,8 +116,8 @@ def sync_dir(path):
 
 
 def safe_fadvise(fd, offset, len, advice):
-    if hasattr(os, 'posix_fadvise'):
-        advice = getattr(os, 'POSIX_FADV_' + advice)
+    if hasattr(os, "posix_fadvise"):
+        advice = getattr(os, "POSIX_FADV_" + advice)
         try:
             os.posix_fadvise(fd, offset, len, advice)
         except OSError:
@@ -158,7 +160,7 @@ class SyncFile:
                that corresponds to path (like from os.open(path, ...) or os.mkstemp(...))
         :param binary: whether to open in binary mode, default is False.
         """
-        mode = 'xb' if binary else 'x'  # x -> raise FileExists exception in open() if file exists already
+        mode = "xb" if binary else "x"  # x -> raise FileExists exception in open() if file exists already
         self.path = path
         if fd is None:
             self.f = open(path, mode=mode)  # python file object
@@ -181,15 +183,17 @@ class SyncFile:
         after sync().
         """
         from .. import platform
+
         self.f.flush()
         platform.fdatasync(self.fd)
         # tell the OS that it does not need to cache what we just wrote,
         # avoids spoiling the cache for the OS and other processes.
-        safe_fadvise(self.fd, 0, 0, 'DONTNEED')
+        safe_fadvise(self.fd, 0, 0, "DONTNEED")
 
     def close(self):
         """sync() and close."""
         from .. import platform
+
         dirname = None
         try:
             dirname = os.path.dirname(self.path)
@@ -216,23 +220,26 @@ class SaveFile:
     Internally used temporary files are created in the target directory and are
     named <BASENAME>-<RANDOMCHARS>.tmp and cleaned up in normal and error conditions.
     """
+
     def __init__(self, path, binary=False):
         self.binary = binary
         self.path = path
         self.dir = os.path.dirname(path)
-        self.tmp_prefix = os.path.basename(path) + '-'
+        self.tmp_prefix = os.path.basename(path) + "-"
         self.tmp_fd = None  # OS-level fd
         self.tmp_fname = None  # full path/filename corresponding to self.tmp_fd
         self.f = None  # python-file-like SyncFile
 
     def __enter__(self):
         from .. import platform
-        self.tmp_fd, self.tmp_fname = tempfile.mkstemp(prefix=self.tmp_prefix, suffix='.tmp', dir=self.dir)
+
+        self.tmp_fd, self.tmp_fname = tempfile.mkstemp(prefix=self.tmp_prefix, suffix=".tmp", dir=self.dir)
         self.f = platform.SyncFile(self.tmp_fname, fd=self.tmp_fd, binary=self.binary)
         return self.f
 
     def __exit__(self, exc_type, exc_val, exc_tb):
         from .. import platform
+
         self.f.close()  # this indirectly also closes self.tmp_fd
         self.tmp_fd = None
         if exc_type is not None:
@@ -246,7 +253,7 @@ class SaveFile:
             # thanks to the crappy os.umask api, we can't query the umask without setting it. :-(
             umask = os.umask(UMASK_DEFAULT)
             os.umask(umask)
-            os.chmod(self.tmp_fname, mode=0o666 & ~ umask)
+            os.chmod(self.tmp_fname, mode=0o666 & ~umask)
         except OSError:
             # chmod might fail if the fs does not support it.
             # this is not harmful, the file will still have permissions for the owner.
@@ -270,13 +277,13 @@ def swidth(s):
 
 
 # patched socket.getfqdn() - see https://bugs.python.org/issue5004
-def getfqdn(name=''):
+def getfqdn(name=""):
     """Get fully qualified domain name from name.
 
     An empty argument is interpreted as meaning the local host.
     """
     name = name.strip()
-    if not name or name == '0.0.0.0':
+    if not name or name == "0.0.0.0":
         name = socket.gethostname()
     try:
         addrs = socket.getaddrinfo(name, None, 0, socket.SOCK_DGRAM, 0, socket.AI_CANONNAME)
@@ -296,14 +303,14 @@ hostname = socket.gethostname()
 fqdn = getfqdn(hostname)
 # some people put the fqdn into /etc/hostname (which is wrong, should be the short hostname)
 # fix this (do the same as "hostname --short" cli command does internally):
-hostname = hostname.split('.')[0]
+hostname = hostname.split(".")[0]
 
 # uuid.getnode() is problematic in some environments (e.g. OpenVZ, see #3968) where the virtual MAC address
 # is all-zero. uuid.getnode falls back to returning a random value in that case, which is not what we want.
 # thus, we offer BORG_HOST_ID where a user can set an own, unique id for each of his hosts.
-hostid = os.environ.get('BORG_HOST_ID')
+hostid = os.environ.get("BORG_HOST_ID")
 if not hostid:
-    hostid = f'{fqdn}@{uuid.getnode()}'
+    hostid = f"{fqdn}@{uuid.getnode()}"
 
 
 def get_process_id():
diff --git a/src/borg/platform/xattr.py b/src/borg/platform/xattr.py
index 74e3d3ab6..ad4f2b7d6 100644
--- a/src/borg/platform/xattr.py
+++ b/src/borg/platform/xattr.py
@@ -18,7 +18,7 @@ def split_string0(buf):
     """split a list of zero-terminated strings into python not-zero-terminated bytes"""
     if isinstance(buf, bytearray):
         buf = bytes(buf)  # use a bytes object, so we return a list of bytes objects
-    return buf.split(b'\0')[:-1]
+    return buf.split(b"\0")[:-1]
 
 
 def split_lstring(buf):
@@ -27,8 +27,8 @@ def split_lstring(buf):
     mv = memoryview(buf)
     while mv:
         length = mv[0]
-        result.append(bytes(mv[1:1 + length]))
-        mv = mv[1 + length:]
+        result.append(bytes(mv[1 : 1 + length]))
+        mv = mv[1 + length :]
     return result
 
 
@@ -38,6 +38,7 @@ class BufferTooSmallError(Exception):
 
 def _check(rv, path=None, detect_buffer_too_small=False):
     from . import get_errno
+
     if rv < 0:
         e = get_errno()
         if detect_buffer_too_small and e == errno.ERANGE:
@@ -48,9 +49,9 @@ def _check(rv, path=None, detect_buffer_too_small=False):
             try:
                 msg = os.strerror(e)
             except ValueError:
-                msg = ''
+                msg = ""
             if isinstance(path, int):
-                path = '<FD %d>' % path
+                path = "<FD %d>" % path
             raise OSError(e, msg, path)
     if detect_buffer_too_small and rv >= len(buffer):
         # freebsd does not error with ERANGE if the buffer is too small,
diff --git a/src/borg/platformflags.py b/src/borg/platformflags.py
index 8bfea7732..64525b8aa 100644
--- a/src/borg/platformflags.py
+++ b/src/borg/platformflags.py
@@ -6,7 +6,7 @@ Use these Flags instead of sys.platform.startswith('<OS>') or try/except.
 
 import sys
 
-is_win32 = sys.platform.startswith('win32')
-is_linux = sys.platform.startswith('linux')
-is_freebsd = sys.platform.startswith('freebsd')
-is_darwin = sys.platform.startswith('darwin')
+is_win32 = sys.platform.startswith("win32")
+is_linux = sys.platform.startswith("linux")
+is_freebsd = sys.platform.startswith("freebsd")
+is_darwin = sys.platform.startswith("darwin")
diff --git a/src/borg/remote.py b/src/borg/remote.py
index 22b078dcd..a1196d600 100644
--- a/src/borg/remote.py
+++ b/src/borg/remote.py
@@ -38,7 +38,7 @@ logger = create_logger(__name__)
 
 RPC_PROTOCOL_VERSION = 2
 BORG_VERSION = parse_version(__version__)
-MSGID, MSG, ARGS, RESULT = 'i', 'm', 'a', 'r'
+MSGID, MSG, ARGS, RESULT = "i", "m", "a", "r"
 
 MAX_INFLIGHT = 100
 
@@ -92,8 +92,8 @@ class UnexpectedRPCDataFormatFromServer(Error):
             data = data.decode()[:128]
         except UnicodeDecodeError:
             data = data[:128]
-            data = ['%02X' % byte for byte in data]
-            data = textwrap.fill(' '.join(data), 16 * 3)
+            data = ["%02X" % byte for byte in data]
+            data = textwrap.fill(" ".join(data), 16 * 3)
         super().__init__(data)
 
 
@@ -119,47 +119,47 @@ class UnexpectedRPCDataFormatFromServer(Error):
 
 
 compatMap = {
-    'check': ('repair', 'save_space', ),
-    'commit': ('save_space', ),
-    'rollback': (),
-    'destroy': (),
-    '__len__': (),
-    'list': ('limit', 'marker', ),
-    'put': ('id', 'data', ),
-    'get': ('id', ),
-    'delete': ('id', ),
-    'save_key': ('keydata', ),
-    'load_key': (),
-    'break_lock': (),
-    'negotiate': ('client_data', ),
-    'open': ('path', 'create', 'lock_wait', 'lock', 'exclusive', 'append_only', ),
-    'info': (),
-    'get_free_nonce': (),
-    'commit_nonce_reservation': ('next_unreserved', 'start_nonce', ),
+    "check": ("repair", "save_space"),
+    "commit": ("save_space",),
+    "rollback": (),
+    "destroy": (),
+    "__len__": (),
+    "list": ("limit", "marker"),
+    "put": ("id", "data"),
+    "get": ("id",),
+    "delete": ("id",),
+    "save_key": ("keydata",),
+    "load_key": (),
+    "break_lock": (),
+    "negotiate": ("client_data",),
+    "open": ("path", "create", "lock_wait", "lock", "exclusive", "append_only"),
+    "info": (),
+    "get_free_nonce": (),
+    "commit_nonce_reservation": ("next_unreserved", "start_nonce"),
 }
 
 
 class RepositoryServer:  # pragma: no cover
     rpc_methods = (
-        '__len__',
-        'check',
-        'commit',
-        'delete',
-        'destroy',
-        'get',
-        'list',
-        'scan',
-        'negotiate',
-        'open',
-        'info',
-        'put',
-        'rollback',
-        'save_key',
-        'load_key',
-        'break_lock',
-        'get_free_nonce',
-        'commit_nonce_reservation',
-        'inject_exception',
+        "__len__",
+        "check",
+        "commit",
+        "delete",
+        "destroy",
+        "get",
+        "list",
+        "scan",
+        "negotiate",
+        "open",
+        "info",
+        "put",
+        "rollback",
+        "save_key",
+        "load_key",
+        "break_lock",
+        "get_free_nonce",
+        "commit_nonce_reservation",
+        "inject_exception",
     )
 
     def __init__(self, restrict_to_paths, restrict_to_repositories, append_only, storage_quota):
@@ -172,14 +172,16 @@ class RepositoryServer:  # pragma: no cover
         # (see RepositoryServer.open below).
         self.append_only = append_only
         self.storage_quota = storage_quota
-        self.client_version = parse_version('1.0.8')  # fallback version if client is too old to send version information
+        self.client_version = parse_version(
+            "1.0.8"
+        )  # fallback version if client is too old to send version information
 
     def positional_to_named(self, method, argv):
         """Translate from positional protocol to named protocol."""
         try:
             return {name: argv[pos] for pos, name in enumerate(compatMap[method])}
         except IndexError:
-            if method == 'open' and len(argv) == 4:
+            if method == "open" and len(argv) == 4:
                 # borg clients < 1.0.7 use open() with 4 args
                 mapping = compatMap[method][:4]
             else:
@@ -198,7 +200,7 @@ class RepositoryServer:  # pragma: no cover
         os.set_blocking(stdin_fd, False)
         os.set_blocking(stdout_fd, True)
         os.set_blocking(stderr_fd, True)
-        unpacker = get_limited_unpacker('server')
+        unpacker = get_limited_unpacker("server")
         while True:
             r, w, es = select.select([stdin_fd], [], [], 10)
             if r:
@@ -207,8 +209,12 @@ class RepositoryServer:  # pragma: no cover
                     if self.repository is not None:
                         self.repository.close()
                     else:
-                        os_write(stderr_fd, 'Borg {}: Got connection close before repository was opened.\n'
-                                 .format(__version__).encode())
+                        os_write(
+                            stderr_fd,
+                            "Borg {}: Got connection close before repository was opened.\n".format(
+                                __version__
+                            ).encode(),
+                        )
                     return
                 unpacker.feed(data)
                 for unpacked in unpacker:
@@ -249,25 +255,34 @@ class RepositoryServer:  # pragma: no cover
                                 # for these, except ErrorWithTraceback, which should always display a traceback.
                                 pass
                             else:
-                                logging.debug('\n'.join(ex_full))
+                                logging.debug("\n".join(ex_full))
 
                             try:
-                                msg = msgpack.packb({MSGID: msgid,
-                                                    'exception_class': e.__class__.__name__,
-                                                    'exception_args': e.args,
-                                                    'exception_full': ex_full,
-                                                    'exception_short': ex_short,
-                                                    'exception_trace': ex_trace,
-                                                    'sysinfo': sysinfo()})
+                                msg = msgpack.packb(
+                                    {
+                                        MSGID: msgid,
+                                        "exception_class": e.__class__.__name__,
+                                        "exception_args": e.args,
+                                        "exception_full": ex_full,
+                                        "exception_short": ex_short,
+                                        "exception_trace": ex_trace,
+                                        "sysinfo": sysinfo(),
+                                    }
+                                )
                             except TypeError:
-                                msg = msgpack.packb({MSGID: msgid,
-                                                    'exception_class': e.__class__.__name__,
-                                                    'exception_args': [x if isinstance(x, (str, bytes, int)) else None
-                                                                       for x in e.args],
-                                                    'exception_full': ex_full,
-                                                    'exception_short': ex_short,
-                                                    'exception_trace': ex_trace,
-                                                    'sysinfo': sysinfo()})
+                                msg = msgpack.packb(
+                                    {
+                                        MSGID: msgid,
+                                        "exception_class": e.__class__.__name__,
+                                        "exception_args": [
+                                            x if isinstance(x, (str, bytes, int)) else None for x in e.args
+                                        ],
+                                        "exception_full": ex_full,
+                                        "exception_short": ex_short,
+                                        "exception_trace": ex_trace,
+                                        "sysinfo": sysinfo(),
+                                    }
+                                )
 
                             os_write(stdout_fd, msg)
                         else:
@@ -282,11 +297,11 @@ class RepositoryServer:  # pragma: no cover
                                     msg = e.get_message()
                                 else:
                                     tb_log_level = logging.ERROR
-                                    msg = '%s Exception in RPC call' % e.__class__.__name__
-                                tb = f'{traceback.format_exc()}\n{sysinfo()}'
+                                    msg = "%s Exception in RPC call" % e.__class__.__name__
+                                tb = f"{traceback.format_exc()}\n{sysinfo()}"
                                 logging.error(msg)
                                 logging.log(tb_log_level, tb)
-                            exc = 'Remote Exception (see remote log for the traceback)'
+                            exc = "Remote Exception (see remote log for the traceback)"
                             os_write(stdout_fd, msgpack.packb((1, msgid, e.__class__.__name__, exc)))
                     else:
                         if dictFormat:
@@ -304,51 +319,52 @@ class RepositoryServer:  # pragma: no cover
         # clients since 1.1.0b3 use a dict as client_data
         # clients since 1.1.0b6 support json log format from server
         if isinstance(client_data, dict):
-            self.client_version = client_data['client_version']
-            level = logging.getLevelName(logging.getLogger('').level)
+            self.client_version = client_data["client_version"]
+            level = logging.getLevelName(logging.getLogger("").level)
             setup_logging(is_serve=True, json=True, level=level)
-            logger.debug('Initialized logging system for JSON-based protocol')
+            logger.debug("Initialized logging system for JSON-based protocol")
         else:
             self.client_version = BORG_VERSION  # seems to be newer than current version (no known old format)
 
         # not a known old format, send newest negotiate this version knows
-        return {'server_version': BORG_VERSION}
+        return {"server_version": BORG_VERSION}
 
     def _resolve_path(self, path):
         if isinstance(path, bytes):
             path = os.fsdecode(path)
         # Leading slash is always present with URI (ssh://), but not with short-form (who@host:path).
-        if path.startswith('/~/'):  # /~/x = path x relative to home dir
+        if path.startswith("/~/"):  # /~/x = path x relative to home dir
             path = os.path.join(get_base_dir(), path[3:])
-        elif path.startswith('~/'):
+        elif path.startswith("~/"):
             path = os.path.join(get_base_dir(), path[2:])
-        elif path.startswith('/~'):  # /~username/x = relative to "user" home dir
+        elif path.startswith("/~"):  # /~username/x = relative to "user" home dir
             path = os.path.expanduser(path[1:])
-        elif path.startswith('~'):
+        elif path.startswith("~"):
             path = os.path.expanduser(path)
-        elif path.startswith('/./'):  # /./x = path x relative to cwd
+        elif path.startswith("/./"):  # /./x = path x relative to cwd
             path = path[3:]
         return os.path.realpath(path)
 
-    def open(self, path, create=False, lock_wait=None, lock=True, exclusive=None, append_only=False,
-             make_parent_dirs=False):
-        logging.debug('Resolving repository path %r', path)
+    def open(
+        self, path, create=False, lock_wait=None, lock=True, exclusive=None, append_only=False, make_parent_dirs=False
+    ):
+        logging.debug("Resolving repository path %r", path)
         path = self._resolve_path(path)
-        logging.debug('Resolved repository path to %r', path)
-        path_with_sep = os.path.join(path, '')  # make sure there is a trailing slash (os.sep)
+        logging.debug("Resolved repository path to %r", path)
+        path_with_sep = os.path.join(path, "")  # make sure there is a trailing slash (os.sep)
         if self.restrict_to_paths:
             # if --restrict-to-path P is given, we make sure that we only operate in/below path P.
             # for the prefix check, it is important that the compared paths both have trailing slashes,
             # so that a path /foobar will NOT be accepted with --restrict-to-path /foo option.
             for restrict_to_path in self.restrict_to_paths:
-                restrict_to_path_with_sep = os.path.join(os.path.realpath(restrict_to_path), '')  # trailing slash
+                restrict_to_path_with_sep = os.path.join(os.path.realpath(restrict_to_path), "")  # trailing slash
                 if path_with_sep.startswith(restrict_to_path_with_sep):
                     break
             else:
                 raise PathNotAllowed(path)
         if self.restrict_to_repositories:
             for restrict_to_repository in self.restrict_to_repositories:
-                restrict_to_repository_with_sep = os.path.join(os.path.realpath(restrict_to_repository), '')
+                restrict_to_repository_with_sep = os.path.join(os.path.realpath(restrict_to_repository), "")
                 if restrict_to_repository_with_sep == path_with_sep:
                     break
             else:
@@ -357,32 +373,37 @@ class RepositoryServer:  # pragma: no cover
         # while "borg init --append-only" (=append_only) does, regardless of the --append-only (self.append_only)
         # flag for serve.
         append_only = (not create and self.append_only) or append_only
-        self.repository = Repository(path, create, lock_wait=lock_wait, lock=lock,
-                                     append_only=append_only,
-                                     storage_quota=self.storage_quota,
-                                     exclusive=exclusive,
-                                     make_parent_dirs=make_parent_dirs)
+        self.repository = Repository(
+            path,
+            create,
+            lock_wait=lock_wait,
+            lock=lock,
+            append_only=append_only,
+            storage_quota=self.storage_quota,
+            exclusive=exclusive,
+            make_parent_dirs=make_parent_dirs,
+        )
         self.repository.__enter__()  # clean exit handled by serve() method
         return self.repository.id
 
     def inject_exception(self, kind):
-        s1 = 'test string'
-        s2 = 'test string2'
-        if kind == 'DoesNotExist':
+        s1 = "test string"
+        s2 = "test string2"
+        if kind == "DoesNotExist":
             raise Repository.DoesNotExist(s1)
-        elif kind == 'AlreadyExists':
+        elif kind == "AlreadyExists":
             raise Repository.AlreadyExists(s1)
-        elif kind == 'CheckNeeded':
+        elif kind == "CheckNeeded":
             raise Repository.CheckNeeded(s1)
-        elif kind == 'IntegrityError':
+        elif kind == "IntegrityError":
             raise IntegrityError(s1)
-        elif kind == 'PathNotAllowed':
-            raise PathNotAllowed('foo')
-        elif kind == 'ObjectNotFound':
+        elif kind == "PathNotAllowed":
+            raise PathNotAllowed("foo")
+        elif kind == "ObjectNotFound":
             raise Repository.ObjectNotFound(s1, s2)
-        elif kind == 'InvalidRPCMethod':
+        elif kind == "InvalidRPCMethod":
             raise InvalidRPCMethod(s1)
-        elif kind == 'divide':
+        elif kind == "divide":
             0 // 0
 
 
@@ -409,7 +430,7 @@ class SleepingBandwidthLimiter:
                 self.ratelimit_quota += self.ratelimit
                 self.ratelimit_last = time.monotonic()
             if len(to_send) > self.ratelimit_quota:
-                to_send = to_send[:self.ratelimit_quota]
+                to_send = to_send[: self.ratelimit_quota]
         written = os.write(fd, to_send)
         if self.ratelimit:
             self.ratelimit_quota -= written
@@ -436,6 +457,7 @@ def api(*, since, **kwargs_decorator):
     more desirable behaviour). If False, an exception is generated.
     E.g. before 'threshold' was introduced in 1.2.0a8, a hardcoded threshold of 0.1 was used in commit().
     """
+
     def decorator(f):
         @functools.wraps(f)
         def do_rpc(self, *args, **kwargs):
@@ -444,10 +466,10 @@ def api(*, since, **kwargs_decorator):
             named = {}  # Arguments for the remote process
             extra = {}  # Arguments for the local process
             for name, param in sig.parameters.items():
-                if name == 'self':
+                if name == "self":
                     continue
                 if name in bound_args.arguments:
-                    if name == 'wait':
+                    if name == "wait":
                         extra[name] = bound_args.arguments[name]
                     else:
                         named[name] = bound_args.arguments[name]
@@ -459,18 +481,21 @@ def api(*, since, **kwargs_decorator):
                 raise self.RPCServerOutdated(f.__name__, format_version(since))
 
             for name, restriction in kwargs_decorator.items():
-                if restriction['since'] <= self.server_version:
+                if restriction["since"] <= self.server_version:
                     continue
-                if 'previously' in restriction and named[name] == restriction['previously']:
+                if "previously" in restriction and named[name] == restriction["previously"]:
                     continue
-                if restriction.get('dontcare', False):
+                if restriction.get("dontcare", False):
                     continue
 
-                raise self.RPCServerOutdated(f"{f.__name__} {name}={named[name]!s}",
-                                             format_version(restriction['since']))
+                raise self.RPCServerOutdated(
+                    f"{f.__name__} {name}={named[name]!s}", format_version(restriction["since"])
+                )
 
             return self.call(f.__name__, named, **extra)
+
         return do_rpc
+
     return decorator
 
 
@@ -484,32 +509,32 @@ class RemoteRepository:
             self.unpacked = unpacked
 
         def get_message(self):
-            if 'exception_short' in self.unpacked:
-                return '\n'.join(self.unpacked['exception_short'])
+            if "exception_short" in self.unpacked:
+                return "\n".join(self.unpacked["exception_short"])
             else:
                 return self.exception_class
 
         @property
         def traceback(self):
-            return self.unpacked.get('exception_trace', True)
+            return self.unpacked.get("exception_trace", True)
 
         @property
         def exception_class(self):
-            return self.unpacked['exception_class']
+            return self.unpacked["exception_class"]
 
         @property
         def exception_full(self):
-            if 'exception_full' in self.unpacked:
-                return '\n'.join(self.unpacked['exception_full'])
+            if "exception_full" in self.unpacked:
+                return "\n".join(self.unpacked["exception_full"])
             else:
-                return self.get_message() + '\nRemote Exception (see remote log for the traceback)'
+                return self.get_message() + "\nRemote Exception (see remote log for the traceback)"
 
         @property
         def sysinfo(self):
-            if 'sysinfo' in self.unpacked:
-                return self.unpacked['sysinfo']
+            if "sysinfo" in self.unpacked:
+                return self.unpacked["sysinfo"]
             else:
-                return ''
+                return ""
 
     class RPCServerOutdated(Error):
         """Borg server is too old for {}. Required version {}"""
@@ -525,15 +550,24 @@ class RemoteRepository:
     # If compatibility with 1.0.x is not longer needed, replace all checks of this with True and simplify the code
     dictFormat = False  # outside of __init__ for testing of legacy free protocol
 
-    def __init__(self, location, create=False, exclusive=False, lock_wait=None, lock=True, append_only=False,
-                 make_parent_dirs=False, args=None):
+    def __init__(
+        self,
+        location,
+        create=False,
+        exclusive=False,
+        lock_wait=None,
+        lock=True,
+        append_only=False,
+        make_parent_dirs=False,
+        args=None,
+    ):
         self.location = self._location = location
         self.preload_ids = []
         self.msgid = 0
         self.rx_bytes = 0
         self.tx_bytes = 0
         self.to_send = EfficientCollectionQueue(1024 * 1024, bytes)
-        self.stderr_received = b''  # incomplete stderr line bytes received (no \n yet)
+        self.stderr_received = b""  # incomplete stderr line bytes received (no \n yet)
         self.chunkid_to_msgids = {}
         self.ignore_responses = set()
         self.responses = {}
@@ -541,18 +575,20 @@ class RemoteRepository:
         self.shutdown_time = None
         self.ratelimit = SleepingBandwidthLimiter(args.upload_ratelimit * 1024 if args and args.upload_ratelimit else 0)
         self.upload_buffer_size_limit = args.upload_buffer * 1024 * 1024 if args and args.upload_buffer else 0
-        self.unpacker = get_limited_unpacker('client')
-        self.server_version = parse_version('1.0.8')  # fallback version if server is too old to send version information
+        self.unpacker = get_limited_unpacker("client")
+        self.server_version = parse_version(
+            "1.0.8"
+        )  # fallback version if server is too old to send version information
         self.p = None
         self._args = args
-        testing = location.host == '__testsuite__'
+        testing = location.host == "__testsuite__"
         # when testing, we invoke and talk to a borg process directly (no ssh).
         # when not testing, we invoke the system-installed ssh binary to talk to a remote borg.
         env = prepare_subprocess_env(system=not testing)
         borg_cmd = self.borg_cmd(args, testing)
         if not testing:
             borg_cmd = self.ssh_cmd(location) + borg_cmd
-        logger.debug('SSH command line: %s', borg_cmd)
+        logger.debug("SSH command line: %s", borg_cmd)
         self.p = Popen(borg_cmd, bufsize=0, stdin=PIPE, stdout=PIPE, stderr=PIPE, env=env)
         self.stdin_fd = self.p.stdin.fileno()
         self.stdout_fd = self.p.stdout.fileno()
@@ -565,26 +601,30 @@ class RemoteRepository:
 
         try:
             try:
-                version = self.call('negotiate', {'client_data': {
-                    'client_version': BORG_VERSION,
-                }})
+                version = self.call("negotiate", {"client_data": {"client_version": BORG_VERSION}})
             except ConnectionClosed:
-                raise ConnectionClosedWithHint('Is borg working on the server?') from None
+                raise ConnectionClosedWithHint("Is borg working on the server?") from None
             if version == RPC_PROTOCOL_VERSION:
                 self.dictFormat = False
-            elif isinstance(version, dict) and 'server_version' in version:
+            elif isinstance(version, dict) and "server_version" in version:
                 self.dictFormat = True
-                self.server_version = version['server_version']
+                self.server_version = version["server_version"]
             else:
-                raise Exception('Server insisted on using unsupported protocol version %s' % version)
+                raise Exception("Server insisted on using unsupported protocol version %s" % version)
 
             def do_open():
-                self.id = self.open(path=self.location.path, create=create, lock_wait=lock_wait,
-                                    lock=lock, exclusive=exclusive, append_only=append_only,
-                                    make_parent_dirs=make_parent_dirs)
+                self.id = self.open(
+                    path=self.location.path,
+                    create=create,
+                    lock_wait=lock_wait,
+                    lock=lock,
+                    exclusive=exclusive,
+                    append_only=append_only,
+                    make_parent_dirs=make_parent_dirs,
+                )
                 info = self.info()
-                self.version = info['version']
-                self.append_only = info['append_only']
+                self.version = info["version"]
+                self.append_only = info["append_only"]
 
             if self.dictFormat:
                 do_open()
@@ -593,7 +633,7 @@ class RemoteRepository:
                 try:
                     do_open()
                 except self.RPCError as err:
-                    if err.exception_class != 'TypeError':
+                    if err.exception_class != "TypeError":
                         raise
                     msg = """\
 Please note:
@@ -605,8 +645,8 @@ This problem will go away as soon as the server has been upgraded to 1.0.7+.
 """
                     # emit this msg in the same way as the 'Remote: ...' lines that show the remote TypeError
                     sys.stderr.write(msg)
-                    self.server_version = parse_version('1.0.6')
-                    compatMap['open'] = ('path', 'create', 'lock_wait', 'lock', )
+                    self.server_version = parse_version("1.0.6")
+                    compatMap["open"] = ("path", "create", "lock_wait", "lock")
                     # try again with corrected version and compatMap
                     do_open()
         except Exception:
@@ -615,13 +655,13 @@ This problem will go away as soon as the server has been upgraded to 1.0.7+.
 
     def __del__(self):
         if len(self.responses):
-            logging.debug('still %d cached responses left in RemoteRepository' % (len(self.responses),))
+            logging.debug("still %d cached responses left in RemoteRepository" % (len(self.responses),))
         if self.p:
             self.close()
-            assert False, 'cleanup happened in Repository.__del__'
+            assert False, "cleanup happened in Repository.__del__"
 
     def __repr__(self):
-        return f'<{self.__class__.__name__} {self.location.canonical_path()}>'
+        return f"<{self.__class__.__name__} {self.location.canonical_path()}>"
 
     def __enter__(self):
         return self
@@ -635,8 +675,12 @@ This problem will go away as soon as the server has been upgraded to 1.0.7+.
             # in any case, we want to cleanly close the repo, even if the
             # rollback can not succeed (e.g. because the connection was
             # already closed) and raised another exception:
-            logger.debug('RemoteRepository: %s bytes sent, %s bytes received, %d messages sent',
-                         format_file_size(self.tx_bytes), format_file_size(self.rx_bytes), self.msgid)
+            logger.debug(
+                "RemoteRepository: %s bytes sent, %s bytes received, %d messages sent",
+                format_file_size(self.tx_bytes),
+                format_file_size(self.rx_bytes),
+                self.msgid,
+            )
             self.close()
 
     @property
@@ -650,17 +694,17 @@ This problem will go away as soon as the server has been upgraded to 1.0.7+.
         if args is not None:
             root_logger = logging.getLogger()
             if root_logger.isEnabledFor(logging.DEBUG):
-                opts.append('--debug')
+                opts.append("--debug")
             elif root_logger.isEnabledFor(logging.INFO):
-                opts.append('--info')
+                opts.append("--info")
             elif root_logger.isEnabledFor(logging.WARNING):
                 pass  # warning is default
             elif root_logger.isEnabledFor(logging.ERROR):
-                opts.append('--error')
+                opts.append("--error")
             elif root_logger.isEnabledFor(logging.CRITICAL):
-                opts.append('--critical')
+                opts.append("--critical")
             else:
-                raise ValueError('log level missing, fix this code')
+                raise ValueError("log level missing, fix this code")
 
             # Tell the remote server about debug topics it may need to consider.
             # Note that debug topics are usable for "spew" or "trace" logs which would
@@ -674,31 +718,31 @@ This problem will go away as soon as the server has been upgraded to 1.0.7+.
             # This is not considered a problem, since this is a debugging feature that
             # should not be used for regular use.
             for topic in args.debug_topics:
-                if '.' not in topic:
-                    topic = 'borg.debug.' + topic
-                if 'repository' in topic:
-                    opts.append('--debug-topic=%s' % topic)
+                if "." not in topic:
+                    topic = "borg.debug." + topic
+                if "repository" in topic:
+                    opts.append("--debug-topic=%s" % topic)
 
-            if 'storage_quota' in args and args.storage_quota:
-                opts.append('--storage-quota=%s' % args.storage_quota)
+            if "storage_quota" in args and args.storage_quota:
+                opts.append("--storage-quota=%s" % args.storage_quota)
         env_vars = []
         if testing:
-            return env_vars + [sys.executable, '-m', 'borg.archiver', 'serve'] + opts + self.extra_test_args
+            return env_vars + [sys.executable, "-m", "borg.archiver", "serve"] + opts + self.extra_test_args
         else:  # pragma: no cover
-            remote_path = args.remote_path or os.environ.get('BORG_REMOTE_PATH', 'borg')
+            remote_path = args.remote_path or os.environ.get("BORG_REMOTE_PATH", "borg")
             remote_path = replace_placeholders(remote_path)
-            return env_vars + [remote_path, 'serve'] + opts
+            return env_vars + [remote_path, "serve"] + opts
 
     def ssh_cmd(self, location):
         """return a ssh command line that can be prefixed to a borg command line"""
-        rsh = self._args.rsh or os.environ.get('BORG_RSH', 'ssh')
+        rsh = self._args.rsh or os.environ.get("BORG_RSH", "ssh")
         args = shlex.split(rsh)
         if location.port:
-            args += ['-p', str(location.port)]
+            args += ["-p", str(location.port)]
         if location.user:
-            args.append(f'{location.user}@{location.host}')
+            args.append(f"{location.user}@{location.host}")
         else:
-            args.append('%s' % location.host)
+            args.append("%s" % location.host)
         return args
 
     def named_to_positional(self, method, kwargs):
@@ -709,7 +753,7 @@ This problem will go away as soon as the server has been upgraded to 1.0.7+.
             return resp
 
     def call_many(self, cmd, calls, wait=True, is_preloaded=False, async_wait=True):
-        if not calls and cmd != 'async_responses':
+        if not calls and cmd != "async_responses":
             return
 
         def send_buffer():
@@ -732,41 +776,41 @@ This problem will go away as soon as the server has been upgraded to 1.0.7+.
             return msgid
 
         def handle_error(unpacked):
-            error = unpacked['exception_class']
-            old_server = 'exception_args' not in unpacked
-            args = unpacked.get('exception_args')
+            error = unpacked["exception_class"]
+            old_server = "exception_args" not in unpacked
+            args = unpacked.get("exception_args")
 
-            if error == 'DoesNotExist':
+            if error == "DoesNotExist":
                 raise Repository.DoesNotExist(self.location.processed)
-            elif error == 'AlreadyExists':
+            elif error == "AlreadyExists":
                 raise Repository.AlreadyExists(self.location.processed)
-            elif error == 'CheckNeeded':
+            elif error == "CheckNeeded":
                 raise Repository.CheckNeeded(self.location.processed)
-            elif error == 'IntegrityError':
+            elif error == "IntegrityError":
                 if old_server:
-                    raise IntegrityError('(not available)')
+                    raise IntegrityError("(not available)")
                 else:
                     raise IntegrityError(args[0])
-            elif error == 'AtticRepository':
+            elif error == "AtticRepository":
                 if old_server:
-                    raise Repository.AtticRepository('(not available)')
+                    raise Repository.AtticRepository("(not available)")
                 else:
                     raise Repository.AtticRepository(args[0])
-            elif error == 'PathNotAllowed':
+            elif error == "PathNotAllowed":
                 if old_server:
-                    raise PathNotAllowed('(unknown)')
+                    raise PathNotAllowed("(unknown)")
                 else:
                     raise PathNotAllowed(args[0])
-            elif error == 'ParentPathDoesNotExist':
+            elif error == "ParentPathDoesNotExist":
                 raise Repository.ParentPathDoesNotExist(args[0])
-            elif error == 'ObjectNotFound':
+            elif error == "ObjectNotFound":
                 if old_server:
-                    raise Repository.ObjectNotFound('(not available)', self.location.processed)
+                    raise Repository.ObjectNotFound("(not available)", self.location.processed)
                 else:
                     raise Repository.ObjectNotFound(args[0], self.location.processed)
-            elif error == 'InvalidRPCMethod':
+            elif error == "InvalidRPCMethod":
                 if old_server:
-                    raise InvalidRPCMethod('(not available)')
+                    raise InvalidRPCMethod("(not available)")
                 else:
                     raise InvalidRPCMethod(args[0])
             else:
@@ -780,14 +824,17 @@ This problem will go away as soon as the server has been upgraded to 1.0.7+.
             if self.shutdown_time and time.monotonic() > self.shutdown_time:
                 # we are shutting this RemoteRepository down already, make sure we do not waste
                 # a lot of time in case a lot of async stuff is coming in or remote is gone or slow.
-                logger.debug('shutdown_time reached, shutting down with %d waiting_for and %d async_responses.',
-                             len(waiting_for), len(self.async_responses))
+                logger.debug(
+                    "shutdown_time reached, shutting down with %d waiting_for and %d async_responses.",
+                    len(waiting_for),
+                    len(self.async_responses),
+                )
                 return
             while waiting_for:
                 try:
                     unpacked = self.responses.pop(waiting_for[0])
                     waiting_for.pop(0)
-                    if 'exception_class' in unpacked:
+                    if "exception_class" in unpacked:
                         handle_error(unpacked)
                     else:
                         yield unpacked[RESULT]
@@ -795,7 +842,7 @@ This problem will go away as soon as the server has been upgraded to 1.0.7+.
                             return
                 except KeyError:
                     break
-            if cmd == 'async_responses':
+            if cmd == "async_responses":
                 while True:
                     try:
                         msgid, unpacked = self.async_responses.popitem()
@@ -807,7 +854,7 @@ This problem will go away as soon as the server has been upgraded to 1.0.7+.
                         else:
                             return
                     else:
-                        if 'exception_class' in unpacked:
+                        if "exception_class" in unpacked:
                             handle_error(unpacked)
                         else:
                             yield unpacked[RESULT]
@@ -817,7 +864,7 @@ This problem will go away as soon as the server has been upgraded to 1.0.7+.
                 w_fds = []
             r, w, x = select.select(self.r_fds, w_fds, self.x_fds, 1)
             if x:
-                raise Exception('FD exception occurred')
+                raise Exception("FD exception occurred")
             for fd in r:
                 if fd is self.stdout_fd:
                     data = os.read(fd, BUFSIZE)
@@ -833,7 +880,7 @@ This problem will go away as soon as the server has been upgraded to 1.0.7+.
                             _, msgid, error, res = unpacked
                             if error:
                                 # ignore res, because it is only a fixed string anyway.
-                                unpacked = {MSGID: msgid, 'exception_class': error}
+                                unpacked = {MSGID: msgid, "exception_class": error}
                             else:
                                 unpacked = {MSGID: msgid, RESULT: res}
                         else:
@@ -841,7 +888,7 @@ This problem will go away as soon as the server has been upgraded to 1.0.7+.
                         if msgid in self.ignore_responses:
                             self.ignore_responses.remove(msgid)
                             # async methods never return values, but may raise exceptions.
-                            if 'exception_class' in unpacked:
+                            if "exception_class" in unpacked:
                                 self.async_responses[msgid] = unpacked
                             else:
                                 # we currently do not have async result values except "None",
@@ -858,83 +905,95 @@ This problem will go away as soon as the server has been upgraded to 1.0.7+.
                     # deal with incomplete lines (may appear due to block buffering)
                     if self.stderr_received:
                         data = self.stderr_received + data
-                        self.stderr_received = b''
+                        self.stderr_received = b""
                     lines = data.splitlines(keepends=True)
-                    if lines and not lines[-1].endswith((b'\r', b'\n')):
+                    if lines and not lines[-1].endswith((b"\r", b"\n")):
                         self.stderr_received = lines.pop()
                     # now we have complete lines in <lines> and any partial line in self.stderr_received.
                     for line in lines:
                         handle_remote_line(line.decode())  # decode late, avoid partial utf-8 sequences
             if w:
-                while (len(self.to_send) <= maximum_to_send) and (calls or self.preload_ids) and len(waiting_for) < MAX_INFLIGHT:
+                while (
+                    (len(self.to_send) <= maximum_to_send)
+                    and (calls or self.preload_ids)
+                    and len(waiting_for) < MAX_INFLIGHT
+                ):
                     if calls:
                         if is_preloaded:
-                            assert cmd == 'get', "is_preload is only supported for 'get'"
-                            if calls[0]['id'] in self.chunkid_to_msgids:
-                                waiting_for.append(pop_preload_msgid(calls.pop(0)['id']))
+                            assert cmd == "get", "is_preload is only supported for 'get'"
+                            if calls[0]["id"] in self.chunkid_to_msgids:
+                                waiting_for.append(pop_preload_msgid(calls.pop(0)["id"]))
                         else:
                             args = calls.pop(0)
-                            if cmd == 'get' and args['id'] in self.chunkid_to_msgids:
-                                waiting_for.append(pop_preload_msgid(args['id']))
+                            if cmd == "get" and args["id"] in self.chunkid_to_msgids:
+                                waiting_for.append(pop_preload_msgid(args["id"]))
                             else:
                                 self.msgid += 1
                                 waiting_for.append(self.msgid)
                                 if self.dictFormat:
                                     self.to_send.push_back(msgpack.packb({MSGID: self.msgid, MSG: cmd, ARGS: args}))
                                 else:
-                                    self.to_send.push_back(msgpack.packb((1, self.msgid, cmd, self.named_to_positional(cmd, args))))
+                                    self.to_send.push_back(
+                                        msgpack.packb((1, self.msgid, cmd, self.named_to_positional(cmd, args)))
+                                    )
                     if not self.to_send and self.preload_ids:
                         chunk_id = self.preload_ids.pop(0)
-                        args = {'id': chunk_id}
+                        args = {"id": chunk_id}
                         self.msgid += 1
                         self.chunkid_to_msgids.setdefault(chunk_id, []).append(self.msgid)
                         if self.dictFormat:
-                            self.to_send.push_back(msgpack.packb({MSGID: self.msgid, MSG: 'get', ARGS: args}))
+                            self.to_send.push_back(msgpack.packb({MSGID: self.msgid, MSG: "get", ARGS: args}))
                         else:
-                            self.to_send.push_back(msgpack.packb((1, self.msgid, 'get', self.named_to_positional('get', args))))
+                            self.to_send.push_back(
+                                msgpack.packb((1, self.msgid, "get", self.named_to_positional("get", args)))
+                            )
 
                 send_buffer()
         self.ignore_responses |= set(waiting_for)  # we lose order here
 
-    @api(since=parse_version('1.0.0'),
-         append_only={'since': parse_version('1.0.7'), 'previously': False},
-         make_parent_dirs={'since': parse_version('1.1.9'), 'previously': False})
-    def open(self, path, create=False, lock_wait=None, lock=True, exclusive=False, append_only=False,
-             make_parent_dirs=False):
+    @api(
+        since=parse_version("1.0.0"),
+        append_only={"since": parse_version("1.0.7"), "previously": False},
+        make_parent_dirs={"since": parse_version("1.1.9"), "previously": False},
+    )
+    def open(
+        self, path, create=False, lock_wait=None, lock=True, exclusive=False, append_only=False, make_parent_dirs=False
+    ):
         """actual remoting is done via self.call in the @api decorator"""
 
-    @api(since=parse_version('2.0.0a3'))
+    @api(since=parse_version("2.0.0a3"))
     def info(self):
         """actual remoting is done via self.call in the @api decorator"""
 
-    @api(since=parse_version('1.0.0'),
-         max_duration={'since': parse_version('1.2.0a4'), 'previously': 0})
+    @api(since=parse_version("1.0.0"), max_duration={"since": parse_version("1.2.0a4"), "previously": 0})
     def check(self, repair=False, save_space=False, max_duration=0):
         """actual remoting is done via self.call in the @api decorator"""
 
-    @api(since=parse_version('1.0.0'),
-         compact={'since': parse_version('1.2.0a0'), 'previously': True, 'dontcare': True},
-         threshold={'since': parse_version('1.2.0a8'), 'previously': 0.1, 'dontcare': True})
+    @api(
+        since=parse_version("1.0.0"),
+        compact={"since": parse_version("1.2.0a0"), "previously": True, "dontcare": True},
+        threshold={"since": parse_version("1.2.0a8"), "previously": 0.1, "dontcare": True},
+    )
     def commit(self, save_space=False, compact=True, threshold=0.1):
         """actual remoting is done via self.call in the @api decorator"""
 
-    @api(since=parse_version('1.0.0'))
+    @api(since=parse_version("1.0.0"))
     def rollback(self):
         """actual remoting is done via self.call in the @api decorator"""
 
-    @api(since=parse_version('1.0.0'))
+    @api(since=parse_version("1.0.0"))
     def destroy(self):
         """actual remoting is done via self.call in the @api decorator"""
 
-    @api(since=parse_version('1.0.0'))
+    @api(since=parse_version("1.0.0"))
     def __len__(self):
         """actual remoting is done via self.call in the @api decorator"""
 
-    @api(since=parse_version('1.0.0'))
+    @api(since=parse_version("1.0.0"))
     def list(self, limit=None, marker=None):
         """actual remoting is done via self.call in the @api decorator"""
 
-    @api(since=parse_version('1.1.0b3'))
+    @api(since=parse_version("1.1.0b3"))
     def scan(self, limit=None, marker=None):
         """actual remoting is done via self.call in the @api decorator"""
 
@@ -943,33 +1002,33 @@ This problem will go away as soon as the server has been upgraded to 1.0.7+.
             return resp
 
     def get_many(self, ids, is_preloaded=False):
-        yield from self.call_many('get', [{'id': id} for id in ids], is_preloaded=is_preloaded)
+        yield from self.call_many("get", [{"id": id} for id in ids], is_preloaded=is_preloaded)
 
-    @api(since=parse_version('1.0.0'))
+    @api(since=parse_version("1.0.0"))
     def put(self, id, data, wait=True):
         """actual remoting is done via self.call in the @api decorator"""
 
-    @api(since=parse_version('1.0.0'))
+    @api(since=parse_version("1.0.0"))
     def delete(self, id, wait=True):
         """actual remoting is done via self.call in the @api decorator"""
 
-    @api(since=parse_version('1.0.0'))
+    @api(since=parse_version("1.0.0"))
     def save_key(self, keydata):
         """actual remoting is done via self.call in the @api decorator"""
 
-    @api(since=parse_version('1.0.0'))
+    @api(since=parse_version("1.0.0"))
     def load_key(self):
         """actual remoting is done via self.call in the @api decorator"""
 
-    @api(since=parse_version('1.0.0'))
+    @api(since=parse_version("1.0.0"))
     def get_free_nonce(self):
         """actual remoting is done via self.call in the @api decorator"""
 
-    @api(since=parse_version('1.0.0'))
+    @api(since=parse_version("1.0.0"))
     def commit_nonce_reservation(self, next_unreserved, start_nonce):
         """actual remoting is done via self.call in the @api decorator"""
 
-    @api(since=parse_version('1.0.0'))
+    @api(since=parse_version("1.0.0"))
     def break_lock(self):
         """actual remoting is done via self.call in the @api decorator"""
 
@@ -981,7 +1040,7 @@ This problem will go away as soon as the server has been upgraded to 1.0.7+.
             self.p = None
 
     def async_response(self, wait=True):
-        for resp in self.call_many('async_responses', calls=[], wait=True, async_wait=wait):
+        for resp in self.call_many("async_responses", calls=[], wait=True, async_wait=wait):
             return resp
 
     def preload(self, ids):
@@ -994,72 +1053,72 @@ def handle_remote_line(line):
 
     This function is remarkably complex because it handles multiple wire formats.
     """
-    assert line.endswith(('\r', '\n'))
-    if line.startswith('{'):
+    assert line.endswith(("\r", "\n"))
+    if line.startswith("{"):
         # This format is used by Borg since 1.1.0b6 for new-protocol clients.
         # It is the same format that is exposed by --log-json.
         msg = json.loads(line)
 
-        if msg['type'] not in ('progress_message', 'progress_percent', 'log_message'):
-            logger.warning('Dropped remote log message with unknown type %r: %s', msg['type'], line)
+        if msg["type"] not in ("progress_message", "progress_percent", "log_message"):
+            logger.warning("Dropped remote log message with unknown type %r: %s", msg["type"], line)
             return
 
-        if msg['type'] == 'log_message':
+        if msg["type"] == "log_message":
             # Re-emit log messages on the same level as the remote to get correct log suppression and verbosity.
-            level = getattr(logging, msg['levelname'], logging.CRITICAL)
+            level = getattr(logging, msg["levelname"], logging.CRITICAL)
             assert isinstance(level, int)
-            target_logger = logging.getLogger(msg['name'])
-            msg['message'] = 'Remote: ' + msg['message']
+            target_logger = logging.getLogger(msg["name"])
+            msg["message"] = "Remote: " + msg["message"]
             # In JSON mode, we manually check whether the log message should be propagated.
-            if logging.getLogger('borg').json and level >= target_logger.getEffectiveLevel():
-                sys.stderr.write(json.dumps(msg) + '\n')
+            if logging.getLogger("borg").json and level >= target_logger.getEffectiveLevel():
+                sys.stderr.write(json.dumps(msg) + "\n")
             else:
-                target_logger.log(level, '%s', msg['message'])
-        elif msg['type'].startswith('progress_'):
+                target_logger.log(level, "%s", msg["message"])
+        elif msg["type"].startswith("progress_"):
             # Progress messages are a bit more complex.
             # First of all, we check whether progress output is enabled. This is signalled
             # through the effective level of the borg.output.progress logger
             # (also see ProgressIndicatorBase in borg.helpers).
-            progress_logger = logging.getLogger('borg.output.progress')
+            progress_logger = logging.getLogger("borg.output.progress")
             if progress_logger.getEffectiveLevel() == logging.INFO:
                 # When progress output is enabled, we check whether the client is in
                 # --log-json mode, as signalled by the "json" attribute on the "borg" logger.
-                if logging.getLogger('borg').json:
+                if logging.getLogger("borg").json:
                     # In --log-json mode we re-emit the progress JSON line as sent by the server,
                     # with the message, if any, prefixed with "Remote: ".
-                    if 'message' in msg:
-                        msg['message'] = 'Remote: ' + msg['message']
-                    sys.stderr.write(json.dumps(msg) + '\n')
-                elif 'message' in msg:
+                    if "message" in msg:
+                        msg["message"] = "Remote: " + msg["message"]
+                    sys.stderr.write(json.dumps(msg) + "\n")
+                elif "message" in msg:
                     # In text log mode we write only the message to stderr and terminate with \r
                     # (carriage return, i.e. move the write cursor back to the beginning of the line)
                     # so that the next message, progress or not, overwrites it. This mirrors the behaviour
                     # of local progress displays.
-                    sys.stderr.write('Remote: ' + msg['message'] + '\r')
-    elif line.startswith('$LOG '):
+                    sys.stderr.write("Remote: " + msg["message"] + "\r")
+    elif line.startswith("$LOG "):
         # This format is used by borg serve 0.xx, 1.0.x and 1.1.0b1..b5.
         # It prefixed log lines with $LOG as a marker, followed by the log level
         # and optionally a logger name, then "Remote:" as a separator followed by the original
         # message.
-        _, level, msg = line.split(' ', 2)
+        _, level, msg = line.split(" ", 2)
         level = getattr(logging, level, logging.CRITICAL)  # str -> int
-        if msg.startswith('Remote:'):
+        if msg.startswith("Remote:"):
             # server format: '$LOG <level> Remote: <msg>'
             logging.log(level, msg.rstrip())
         else:
             # server format '$LOG <level> <logname> Remote: <msg>'
-            logname, msg = msg.split(' ', 1)
+            logname, msg = msg.split(" ", 1)
             logging.getLogger(logname).log(level, msg.rstrip())
     else:
         # Plain 1.0.x and older format - re-emit to stderr (mirroring what the 1.0.x
         # client did) or as a generic log message.
         # We don't know what priority the line had.
-        if logging.getLogger('borg').json:
-            logging.getLogger('').warning('Remote: ' + line.strip())
+        if logging.getLogger("borg").json:
+            logging.getLogger("").warning("Remote: " + line.strip())
         else:
             # In non-JSON mode we circumvent logging to preserve carriage returns (\r)
             # which are generated by remote progress displays.
-            sys.stderr.write('Remote: ' + line)
+            sys.stderr.write("Remote: " + line)
 
 
 class RepositoryNoCache:
@@ -1071,6 +1130,7 @@ class RepositoryNoCache:
     The return value is returned from get()/get_many(). By default, the raw
     repository data is returned.
     """
+
     def __init__(self, repository, transform=None):
         self.repository = repository
         self.transform = transform or (lambda key, data: data)
@@ -1112,7 +1172,7 @@ class RepositoryCache(RepositoryNoCache):
         self.pack = pack or (lambda data: data)
         self.unpack = unpack or (lambda data: data)
         self.cache = set()
-        self.basedir = tempfile.mkdtemp(prefix='borg-cache-')
+        self.basedir = tempfile.mkdtemp(prefix="borg-cache-")
         self.query_size_limit()
         self.size = 0
         # Instrumentation
@@ -1147,7 +1207,7 @@ class RepositoryCache(RepositoryNoCache):
         packed = self.pack(transformed)
         file = self.key_filename(key)
         try:
-            with open(file, 'wb') as fd:
+            with open(file, "wb") as fd:
                 fd.write(packed)
         except OSError as os_error:
             try:
@@ -1167,11 +1227,19 @@ class RepositoryCache(RepositoryNoCache):
         return transformed
 
     def log_instrumentation(self):
-        logger.debug('RepositoryCache: current items %d, size %s / %s, %d hits, %d misses, %d slow misses (+%.1fs), '
-                     '%d evictions, %d ENOSPC hit',
-                     len(self.cache), format_file_size(self.size), format_file_size(self.size_limit),
-                     self.hits, self.misses, self.slow_misses, self.slow_lat,
-                     self.evictions, self.enospc)
+        logger.debug(
+            "RepositoryCache: current items %d, size %s / %s, %d hits, %d misses, %d slow misses (+%.1fs), "
+            "%d evictions, %d ENOSPC hit",
+            len(self.cache),
+            format_file_size(self.size),
+            format_file_size(self.size_limit),
+            self.hits,
+            self.misses,
+            self.slow_misses,
+            self.slow_lat,
+            self.evictions,
+            self.enospc,
+        )
 
     def close(self):
         self.log_instrumentation()
@@ -1184,7 +1252,7 @@ class RepositoryCache(RepositoryNoCache):
         for key in keys:
             if key in self.cache:
                 file = self.key_filename(key)
-                with open(file, 'rb') as fd:
+                with open(file, "rb") as fd:
                     self.hits += 1
                     yield self.unpack(fd.read())
             else:
@@ -1218,12 +1286,12 @@ def cache_if_remote(repository, *, decrypted_cache=False, pack=None, unpack=None
     Internally, objects are compressed with LZ4.
     """
     if decrypted_cache and (pack or unpack or transform):
-        raise ValueError('decrypted_cache and pack/unpack/transform are incompatible')
+        raise ValueError("decrypted_cache and pack/unpack/transform are incompatible")
     elif decrypted_cache:
         key = decrypted_cache
         # 32 bit csize, 64 bit (8 byte) xxh64
-        cache_struct = struct.Struct('=I8s')
-        compressor = Compressor('lz4')
+        cache_struct = struct.Struct("=I8s")
+        compressor = Compressor("lz4")
 
         def pack(data):
             csize, decrypted = data
@@ -1232,10 +1300,10 @@ def cache_if_remote(repository, *, decrypted_cache=False, pack=None, unpack=None
 
         def unpack(data):
             data = memoryview(data)
-            csize, checksum = cache_struct.unpack(data[:cache_struct.size])
-            compressed = data[cache_struct.size:]
+            csize, checksum = cache_struct.unpack(data[: cache_struct.size])
+            compressed = data[cache_struct.size :]
             if checksum != xxh64(compressed):
-                raise IntegrityError('detected corrupted data in metadata cache')
+                raise IntegrityError("detected corrupted data in metadata cache")
             return csize, compressor.decompress(compressed)
 
         def transform(id_, data):
diff --git a/src/borg/repository.py b/src/borg/repository.py
index ba193243c..3a05b09ef 100644
--- a/src/borg/repository.py
+++ b/src/borg/repository.py
@@ -30,9 +30,9 @@ from .crypto.file_integrity import IntegrityCheckedFile, FileIntegrityError
 
 logger = create_logger(__name__)
 
-MAGIC = b'BORG_SEG'
+MAGIC = b"BORG_SEG"
 MAGIC_LEN = len(MAGIC)
-ATTIC_MAGIC = b'ATTICSEG'
+ATTIC_MAGIC = b"ATTICSEG"
 assert len(ATTIC_MAGIC) == MAGIC_LEN
 
 TAG_PUT = 0
@@ -172,11 +172,20 @@ class Repository:
     class StorageQuotaExceeded(Error):
         """The storage quota ({}) has been exceeded ({}). Try deleting some archives."""
 
-    def __init__(self, path, create=False, exclusive=False, lock_wait=None, lock=True,
-                 append_only=False, storage_quota=None, check_segment_magic=True,
-                 make_parent_dirs=False):
+    def __init__(
+        self,
+        path,
+        create=False,
+        exclusive=False,
+        lock_wait=None,
+        lock=True,
+        append_only=False,
+        storage_quota=None,
+        check_segment_magic=True,
+        make_parent_dirs=False,
+    ):
         self.path = os.path.abspath(path)
-        self._location = Location('file://%s' % self.path)
+        self._location = Location("file://%s" % self.path)
         self.version = None
         self.io = None  # type: LoggedIO
         self.lock = None
@@ -201,7 +210,7 @@ class Repository:
         # v2 is the default repo version for borg 2.0
         # v1 repos must only be used in a read-only way, e.g. for
         # --other-repo=V1_REPO with borg init and borg transfer!
-        self.acceptable_repo_versions = (1, 2, )
+        self.acceptable_repo_versions = (1, 2)
 
     def __del__(self):
         if self.lock:
@@ -209,7 +218,7 @@ class Repository:
             assert False, "cleanup happened in Repository.__del__"
 
     def __repr__(self):
-        return f'<{self.__class__.__name__} {self.path}>'
+        return f"<{self.__class__.__name__} {self.path}>"
 
     def __enter__(self):
         if self.do_create:
@@ -225,7 +234,7 @@ class Repository:
             # The ENOSPC could have originated somewhere else besides the Repository. The cleanup is always safe, unless
             # EIO or FS corruption ensues, which is why we specifically check for ENOSPC.
             if self._active_txn and no_space_left_on_device:
-                logger.warning('No space left on device, cleaning up partial transaction to free space.')
+                logger.warning("No space left on device, cleaning up partial transaction to free space.")
                 cleanup = True
             else:
                 cleanup = False
@@ -241,12 +250,12 @@ class Repository:
         """Check whether there is already a Borg repository at *path*."""
         try:
             # Use binary mode to avoid troubles if a README contains some stuff not in our locale
-            with open(os.path.join(path, 'README'), 'rb') as fd:
+            with open(os.path.join(path, "README"), "rb") as fd:
                 # Read only the first ~100 bytes (if any), in case some README file we stumble upon is large.
                 readme_head = fd.read(100)
                 # The first comparison captures our current variant (REPOSITORY_README), the second comparison
                 # is an older variant of the README file (used by 1.0.x).
-                return b'Borg Backup repository' in readme_head or b'Borg repository' in readme_head
+                return b"Borg Backup repository" in readme_head or b"Borg repository" in readme_head
         except OSError:
             # Ignore FileNotFound, PermissionError, ...
             return False
@@ -287,8 +296,7 @@ class Repository:
                 raise self.AlreadyExists(path)
 
     def create(self, path):
-        """Create a new empty repository at `path`
-        """
+        """Create a new empty repository at `path`"""
         self.check_can_create_repository(path)
         if self.make_parent_dirs:
             parent_path = os.path.join(path, os.pardir)
@@ -298,35 +306,37 @@ class Repository:
                 os.mkdir(path)
             except FileNotFoundError as err:
                 raise self.ParentPathDoesNotExist(path) from err
-        with open(os.path.join(path, 'README'), 'w') as fd:
+        with open(os.path.join(path, "README"), "w") as fd:
             fd.write(REPOSITORY_README)
-        os.mkdir(os.path.join(path, 'data'))
+        os.mkdir(os.path.join(path, "data"))
         config = ConfigParser(interpolation=None)
-        config.add_section('repository')
+        config.add_section("repository")
         self.version = 2
-        config.set('repository', 'version', str(self.version))
-        config.set('repository', 'segments_per_dir', str(DEFAULT_SEGMENTS_PER_DIR))
-        config.set('repository', 'max_segment_size', str(DEFAULT_MAX_SEGMENT_SIZE))
-        config.set('repository', 'append_only', str(int(self.append_only)))
+        config.set("repository", "version", str(self.version))
+        config.set("repository", "segments_per_dir", str(DEFAULT_SEGMENTS_PER_DIR))
+        config.set("repository", "max_segment_size", str(DEFAULT_MAX_SEGMENT_SIZE))
+        config.set("repository", "append_only", str(int(self.append_only)))
         if self.storage_quota:
-            config.set('repository', 'storage_quota', str(self.storage_quota))
+            config.set("repository", "storage_quota", str(self.storage_quota))
         else:
-            config.set('repository', 'storage_quota', '0')
-        config.set('repository', 'additional_free_space', '0')
-        config.set('repository', 'id', bin_to_hex(os.urandom(32)))
+            config.set("repository", "storage_quota", "0")
+        config.set("repository", "additional_free_space", "0")
+        config.set("repository", "id", bin_to_hex(os.urandom(32)))
         self.save_config(path, config)
 
     def save_config(self, path, config):
-        config_path = os.path.join(path, 'config')
-        old_config_path = os.path.join(path, 'config.old')
+        config_path = os.path.join(path, "config")
+        old_config_path = os.path.join(path, "config.old")
 
         if os.path.isfile(old_config_path):
             logger.warning("Old config file not securely erased on previous config update")
             secure_erase(old_config_path, avoid_collateral_damage=True)
 
         if os.path.isfile(config_path):
-            link_error_msg = ("Failed to securely erase old repository config file (hardlinks not supported). "
-                              "Old repokey data, if any, might persist on physical storage.")
+            link_error_msg = (
+                "Failed to securely erase old repository config file (hardlinks not supported). "
+                "Old repokey data, if any, might persist on physical storage."
+            )
             try:
                 os.link(config_path, old_config_path)
             except OSError as e:
@@ -345,32 +355,34 @@ class Repository:
             # error is only a problem if we even had a lock
             if self.do_lock:
                 raise
-            logger.warning("%s: Failed writing to '%s'. This is expected when working on "
-                           "read-only repositories." % (e.strerror, e.filename))
+            logger.warning(
+                "%s: Failed writing to '%s'. This is expected when working on "
+                "read-only repositories." % (e.strerror, e.filename)
+            )
 
         if os.path.isfile(old_config_path):
             secure_erase(old_config_path, avoid_collateral_damage=True)
 
     def save_key(self, keydata):
         assert self.config
-        keydata = keydata.decode('utf-8')  # remote repo: msgpack issue #99, getting bytes
+        keydata = keydata.decode("utf-8")  # remote repo: msgpack issue #99, getting bytes
         # note: saving an empty key means that there is no repokey any more
-        self.config.set('repository', 'key', keydata)
+        self.config.set("repository", "key", keydata)
         self.save_config(self.path, self.config)
 
     def load_key(self):
-        keydata = self.config.get('repository', 'key', fallback='').strip()
+        keydata = self.config.get("repository", "key", fallback="").strip()
         # note: if we return an empty string, it means there is no repo key
-        return keydata.encode('utf-8')  # remote repo: msgpack issue #99, returning bytes
+        return keydata.encode("utf-8")  # remote repo: msgpack issue #99, returning bytes
 
     def get_free_nonce(self):
         if self.do_lock and not self.lock.got_exclusive_lock():
             raise AssertionError("bug in code, exclusive lock should exist here")
 
-        nonce_path = os.path.join(self.path, 'nonce')
+        nonce_path = os.path.join(self.path, "nonce")
         try:
             with open(nonce_path) as fd:
-                return int.from_bytes(unhexlify(fd.read()), byteorder='big')
+                return int.from_bytes(unhexlify(fd.read()), byteorder="big")
         except FileNotFoundError:
             return None
 
@@ -380,30 +392,33 @@ class Repository:
 
         if self.get_free_nonce() != start_nonce:
             raise Exception("nonce space reservation with mismatched previous state")
-        nonce_path = os.path.join(self.path, 'nonce')
+        nonce_path = os.path.join(self.path, "nonce")
         try:
             with SaveFile(nonce_path, binary=False) as fd:
-                fd.write(bin_to_hex(next_unreserved.to_bytes(8, byteorder='big')))
+                fd.write(bin_to_hex(next_unreserved.to_bytes(8, byteorder="big")))
         except PermissionError as e:
             # error is only a problem if we even had a lock
             if self.do_lock:
                 raise
-            logger.warning("%s: Failed writing to '%s'. This is expected when working on "
-                           "read-only repositories." % (e.strerror, e.filename))
+            logger.warning(
+                "%s: Failed writing to '%s'. This is expected when working on "
+                "read-only repositories." % (e.strerror, e.filename)
+            )
 
     def destroy(self):
-        """Destroy the repository at `self.path`
-        """
+        """Destroy the repository at `self.path`"""
         if self.append_only:
             raise ValueError(self.path + " is in append-only mode")
         self.close()
-        os.remove(os.path.join(self.path, 'config'))  # kill config first
+        os.remove(os.path.join(self.path, "config"))  # kill config first
         shutil.rmtree(self.path)
 
     def get_index_transaction_id(self):
-        indices = sorted(int(fn[6:])
-                         for fn in os.listdir(self.path)
-                         if fn.startswith('index.') and fn[6:].isdigit() and os.stat(os.path.join(self.path, fn)).st_size != 0)
+        indices = sorted(
+            int(fn[6:])
+            for fn in os.listdir(self.path)
+            if fn.startswith("index.") and fn[6:].isdigit() and os.stat(os.path.join(self.path, fn)).st_size != 0
+        )
         if indices:
             return indices[-1]
         else:
@@ -434,7 +449,7 @@ class Repository:
         return self.get_index_transaction_id()
 
     def break_lock(self):
-        Lock(os.path.join(self.path, 'lock')).break_lock()
+        Lock(os.path.join(self.path, "lock")).break_lock()
 
     def migrate_lock(self, old_id, new_id):
         # note: only needed for local repos
@@ -450,39 +465,38 @@ class Repository:
         if not stat.S_ISDIR(st.st_mode):
             raise self.InvalidRepository(path)
         if lock:
-            self.lock = Lock(os.path.join(path, 'lock'), exclusive, timeout=lock_wait).acquire()
+            self.lock = Lock(os.path.join(path, "lock"), exclusive, timeout=lock_wait).acquire()
         else:
             self.lock = None
         self.config = ConfigParser(interpolation=None)
         try:
-            with open(os.path.join(self.path, 'config')) as fd:
+            with open(os.path.join(self.path, "config")) as fd:
                 self.config.read_file(fd)
         except FileNotFoundError:
             self.close()
             raise self.InvalidRepository(self.path)
-        if 'repository' not in self.config.sections():
+        if "repository" not in self.config.sections():
             self.close()
-            raise self.InvalidRepositoryConfig(path, 'no repository section found')
-        self.version = self.config.getint('repository', 'version')
+            raise self.InvalidRepositoryConfig(path, "no repository section found")
+        self.version = self.config.getint("repository", "version")
         if self.version not in self.acceptable_repo_versions:
             self.close()
             raise self.InvalidRepositoryConfig(
-                path,
-                'repository version %d is not supported by this borg version' % self.version
+                path, "repository version %d is not supported by this borg version" % self.version
             )
-        self.max_segment_size = parse_file_size(self.config.get('repository', 'max_segment_size'))
+        self.max_segment_size = parse_file_size(self.config.get("repository", "max_segment_size"))
         if self.max_segment_size >= MAX_SEGMENT_SIZE_LIMIT:
             self.close()
-            raise self.InvalidRepositoryConfig(path, 'max_segment_size >= %d' % MAX_SEGMENT_SIZE_LIMIT)  # issue 3592
-        self.segments_per_dir = self.config.getint('repository', 'segments_per_dir')
-        self.additional_free_space = parse_file_size(self.config.get('repository', 'additional_free_space', fallback=0))
+            raise self.InvalidRepositoryConfig(path, "max_segment_size >= %d" % MAX_SEGMENT_SIZE_LIMIT)  # issue 3592
+        self.segments_per_dir = self.config.getint("repository", "segments_per_dir")
+        self.additional_free_space = parse_file_size(self.config.get("repository", "additional_free_space", fallback=0))
         # append_only can be set in the constructor
         # it shouldn't be overridden (True -> False) here
-        self.append_only = self.append_only or self.config.getboolean('repository', 'append_only', fallback=False)
+        self.append_only = self.append_only or self.config.getboolean("repository", "append_only", fallback=False)
         if self.storage_quota is None:
             # self.storage_quota is None => no explicit storage_quota was specified, use repository setting.
-            self.storage_quota = parse_file_size(self.config.get('repository', 'storage_quota', fallback=0))
-        self.id = unhexlify(self.config.get('repository', 'id').strip())
+            self.storage_quota = parse_file_size(self.config.get("repository", "storage_quota", fallback=0))
+        self.id = unhexlify(self.config.get("repository", "id").strip())
         self.io = LoggedIO(self.path, self.max_segment_size, self.segments_per_dir)
         if self.check_segment_magic:
             # read a segment and check whether we are dealing with a non-upgraded Attic repository
@@ -493,11 +507,7 @@ class Repository:
 
     def info(self):
         """return some infos about the repo (must be opened first)"""
-        return dict(
-            id=self.id,
-            version=self.version,
-            append_only=self.append_only,
-        )
+        return dict(id=self.id, version=self.version, append_only=self.append_only)
 
     def close(self):
         if self.lock:
@@ -508,8 +518,7 @@ class Repository:
             self.lock = None
 
     def commit(self, save_space=False, compact=True, threshold=0.1):
-        """Commit transaction
-        """
+        """Commit transaction"""
         # save_space is not used anymore, but stays for RPC/API compatibility.
         if self.transaction_doomed:
             exception = self.transaction_doomed
@@ -526,32 +535,32 @@ class Repository:
         self.rollback()
 
     def _read_integrity(self, transaction_id, key):
-        integrity_file = 'integrity.%d' % transaction_id
+        integrity_file = "integrity.%d" % transaction_id
         integrity_path = os.path.join(self.path, integrity_file)
         try:
-            with open(integrity_path, 'rb') as fd:
+            with open(integrity_path, "rb") as fd:
                 integrity = msgpack.unpack(fd)
         except FileNotFoundError:
             return
-        if integrity.get('version') != 2:
-            logger.warning('Unknown integrity data version %r in %s', integrity.get('version'), integrity_file)
+        if integrity.get("version") != 2:
+            logger.warning("Unknown integrity data version %r in %s", integrity.get("version"), integrity_file)
             return
         return integrity[key]
 
     def open_index(self, transaction_id, auto_recover=True):
         if transaction_id is None:
             return NSIndex()
-        index_path = os.path.join(self.path, 'index.%d' % transaction_id)
+        index_path = os.path.join(self.path, "index.%d" % transaction_id)
         variant = hashindex_variant(index_path)
-        integrity_data = self._read_integrity(transaction_id, 'index')
+        integrity_data = self._read_integrity(transaction_id, "index")
         try:
             with IntegrityCheckedFile(index_path, write=False, integrity_data=integrity_data) as fd:
-                if variant == 'k32_v16':
+                if variant == "k32_v16":
                     return NSIndex.read(fd)
-                if variant == 'k32_v8':  # legacy
+                if variant == "k32_v8":  # legacy
                     return NSIndex1.read(fd)
         except (ValueError, OSError, FileIntegrityError) as exc:
-            logger.warning('Repository index missing or corrupted, trying to recover from: %s', exc)
+            logger.warning("Repository index missing or corrupted, trying to recover from: %s", exc)
             os.unlink(index_path)
             if not auto_recover:
                 raise
@@ -583,7 +592,7 @@ class Repository:
             try:
                 self.index = self.open_index(transaction_id, auto_recover=False)
             except (ValueError, OSError, FileIntegrityError) as exc:
-                logger.warning('Checking repository transaction due to previous error: %s', exc)
+                logger.warning("Checking repository transaction due to previous error: %s", exc)
                 self.check_transaction()
                 self.index = self.open_index(transaction_id, auto_recover=False)
         if transaction_id is None:
@@ -594,14 +603,14 @@ class Repository:
         else:
             if do_cleanup:
                 self.io.cleanup(transaction_id)
-            hints_path = os.path.join(self.path, 'hints.%d' % transaction_id)
-            index_path = os.path.join(self.path, 'index.%d' % transaction_id)
-            integrity_data = self._read_integrity(transaction_id, 'hints')
+            hints_path = os.path.join(self.path, "hints.%d" % transaction_id)
+            index_path = os.path.join(self.path, "index.%d" % transaction_id)
+            integrity_data = self._read_integrity(transaction_id, "hints")
             try:
                 with IntegrityCheckedFile(hints_path, write=False, integrity_data=integrity_data) as fd:
                     hints = msgpack.unpack(fd)
             except (msgpack.UnpackException, FileNotFoundError, FileIntegrityError) as e:
-                logger.warning('Repository hints file missing or corrupted, trying to recover: %s', e)
+                logger.warning("Repository hints file missing or corrupted, trying to recover: %s", e)
                 if not isinstance(e, FileNotFoundError):
                     os.unlink(hints_path)
                 # index must exist at this point
@@ -609,23 +618,23 @@ class Repository:
                 self.check_transaction()
                 self.prepare_txn(transaction_id)
                 return
-            if hints['version'] == 1:
-                logger.debug('Upgrading from v1 hints.%d', transaction_id)
-                self.segments = hints['segments']
+            if hints["version"] == 1:
+                logger.debug("Upgrading from v1 hints.%d", transaction_id)
+                self.segments = hints["segments"]
                 self.compact = FreeSpace()
                 self.storage_quota_use = 0
                 self.shadow_index = {}
-                for segment in sorted(hints['compact']):
-                    logger.debug('Rebuilding sparse info for segment %d', segment)
+                for segment in sorted(hints["compact"]):
+                    logger.debug("Rebuilding sparse info for segment %d", segment)
                     self._rebuild_sparse(segment)
-                logger.debug('Upgrade to v2 hints complete')
-            elif hints['version'] != 2:
-                raise ValueError('Unknown hints file version: %d' % hints['version'])
+                logger.debug("Upgrade to v2 hints complete")
+            elif hints["version"] != 2:
+                raise ValueError("Unknown hints file version: %d" % hints["version"])
             else:
-                self.segments = hints['segments']
-                self.compact = FreeSpace(hints['compact'])
-                self.storage_quota_use = hints.get('storage_quota_use', 0)
-                self.shadow_index = hints.get('shadow_index', {})
+                self.segments = hints["segments"]
+                self.compact = FreeSpace(hints["compact"])
+                self.storage_quota_use = hints.get("storage_quota_use", 0)
+                self.shadow_index = hints.get("shadow_index", {})
             self.log_storage_quota()
             # Drop uncommitted segments in the shadow index
             for key, shadowed_segments in self.shadow_index.items():
@@ -639,50 +648,51 @@ class Repository:
             os.fsync(fd.fileno())
 
         def rename_tmp(file):
-            os.rename(file + '.tmp', file)
+            os.rename(file + ".tmp", file)
 
         hints = {
-            'version': 2,
-            'segments': self.segments,
-            'compact': self.compact,
-            'storage_quota_use': self.storage_quota_use,
-            'shadow_index': self.shadow_index,
+            "version": 2,
+            "segments": self.segments,
+            "compact": self.compact,
+            "storage_quota_use": self.storage_quota_use,
+            "shadow_index": self.shadow_index,
         }
         integrity = {
             # Integrity version started at 2, the current hints version.
             # Thus, integrity version == hints version, for now.
-            'version': 2,
+            "version": 2
         }
         transaction_id = self.io.get_segments_transaction_id()
         assert transaction_id is not None
 
         # Log transaction in append-only mode
         if self.append_only:
-            with open(os.path.join(self.path, 'transactions'), 'a') as log:
-                print('transaction %d, UTC time %s' % (
-                      transaction_id, datetime.utcnow().strftime(ISO_FORMAT)), file=log)
+            with open(os.path.join(self.path, "transactions"), "a") as log:
+                print(
+                    "transaction %d, UTC time %s" % (transaction_id, datetime.utcnow().strftime(ISO_FORMAT)), file=log
+                )
 
         # Write hints file
-        hints_name = 'hints.%d' % transaction_id
+        hints_name = "hints.%d" % transaction_id
         hints_file = os.path.join(self.path, hints_name)
-        with IntegrityCheckedFile(hints_file + '.tmp', filename=hints_name, write=True) as fd:
+        with IntegrityCheckedFile(hints_file + ".tmp", filename=hints_name, write=True) as fd:
             msgpack.pack(hints, fd)
             flush_and_sync(fd)
-        integrity['hints'] = fd.integrity_data
+        integrity["hints"] = fd.integrity_data
 
         # Write repository index
-        index_name = 'index.%d' % transaction_id
+        index_name = "index.%d" % transaction_id
         index_file = os.path.join(self.path, index_name)
-        with IntegrityCheckedFile(index_file + '.tmp', filename=index_name, write=True) as fd:
+        with IntegrityCheckedFile(index_file + ".tmp", filename=index_name, write=True) as fd:
             # XXX: Consider using SyncFile for index write-outs.
             self.index.write(fd)
             flush_and_sync(fd)
-        integrity['index'] = fd.integrity_data
+        integrity["index"] = fd.integrity_data
 
         # Write integrity file, containing checksums of the hints and index files
-        integrity_name = 'integrity.%d' % transaction_id
+        integrity_name = "integrity.%d" % transaction_id
         integrity_file = os.path.join(self.path, integrity_name)
-        with open(integrity_file + '.tmp', 'wb') as fd:
+        with open(integrity_file + ".tmp", "wb") as fd:
             msgpack.pack(integrity, fd)
             flush_and_sync(fd)
 
@@ -695,9 +705,9 @@ class Repository:
         sync_dir(self.path)
 
         # Remove old auxiliary files
-        current = '.%d' % transaction_id
+        current = ".%d" % transaction_id
         for name in os.listdir(self.path):
-            if not name.startswith(('index.', 'hints.', 'integrity.')):
+            if not name.startswith(("index.", "hints.", "integrity.")):
                 continue
             if name.endswith(current):
                 continue
@@ -737,9 +747,11 @@ class Repository:
                     except FileNotFoundError:
                         # looks like self.compact is referring to a non-existent segment file, ignore it.
                         pass
-                logger.debug('check_free_space: few segments, not requiring a full free segment')
+                logger.debug("check_free_space: few segments, not requiring a full free segment")
                 compact_working_space = min(compact_working_space, full_segment_size)
-                logger.debug('check_free_space: calculated working space for compact as %d bytes', compact_working_space)
+                logger.debug(
+                    "check_free_space: calculated working space for compact as %d bytes", compact_working_space
+                )
                 required_free_space += compact_working_space
             else:
                 # Keep one full worst-case segment free in non-append-only mode
@@ -748,12 +760,12 @@ class Repository:
         try:
             free_space = shutil.disk_usage(self.path).free
         except OSError as os_error:
-            logger.warning('Failed to check free space before committing: ' + str(os_error))
+            logger.warning("Failed to check free space before committing: " + str(os_error))
             return
-        logger.debug(f'check_free_space: required bytes {required_free_space}, free bytes {free_space}')
+        logger.debug(f"check_free_space: required bytes {required_free_space}, free bytes {free_space}")
         if free_space < required_free_space:
             if self.created:
-                logger.error('Not enough free space to initialize repository at this location.')
+                logger.error("Not enough free space to initialize repository at this location.")
                 self.destroy()
             else:
                 self._rollback(cleanup=True)
@@ -763,14 +775,16 @@ class Repository:
 
     def log_storage_quota(self):
         if self.storage_quota:
-            logger.info('Storage quota: %s out of %s used.',
-                        format_file_size(self.storage_quota_use), format_file_size(self.storage_quota))
+            logger.info(
+                "Storage quota: %s out of %s used.",
+                format_file_size(self.storage_quota_use),
+                format_file_size(self.storage_quota),
+            )
 
     def compact_segments(self, threshold):
-        """Compact sparse segments by copying data into new segments
-        """
+        """Compact sparse segments by copying data into new segments"""
         if not self.compact:
-            logger.debug('nothing to do: compact empty')
+            logger.debug("nothing to do: compact empty")
             return
         quota_use_before = self.storage_quota_use
         index_transaction_id = self.get_index_transaction_id()
@@ -784,22 +798,25 @@ class Repository:
             segment = self.io.write_commit(intermediate=intermediate)
             self.segments.setdefault(segment, 0)
             self.compact[segment] += LoggedIO.header_fmt.size
-            logger.debug('complete_xfer: wrote %scommit at segment %d', 'intermediate ' if intermediate else '', segment)
+            logger.debug(
+                "complete_xfer: wrote %scommit at segment %d", "intermediate " if intermediate else "", segment
+            )
             # get rid of the old, sparse, unused segments. free space.
             for segment in unused:
-                logger.debug('complete_xfer: deleting unused segment %d', segment)
+                logger.debug("complete_xfer: deleting unused segment %d", segment)
                 count = self.segments.pop(segment)
-                assert count == 0, 'Corrupted segment reference count - corrupted index or hints'
+                assert count == 0, "Corrupted segment reference count - corrupted index or hints"
                 self.io.delete_segment(segment)
                 del self.compact[segment]
             unused = []
 
-        logger.debug('Compaction started (threshold is %i%%).', threshold * 100)
-        pi = ProgressIndicatorPercent(total=len(self.compact), msg='Compacting segments %3.0f%%', step=1,
-                                      msgid='repository.compact_segments')
+        logger.debug("Compaction started (threshold is %i%%).", threshold * 100)
+        pi = ProgressIndicatorPercent(
+            total=len(self.compact), msg="Compacting segments %3.0f%%", step=1, msgid="repository.compact_segments"
+        )
         for segment, freeable_space in sorted(self.compact.items()):
             if not self.io.segment_exists(segment):
-                logger.warning('segment %d not found, but listed in compaction data', segment)
+                logger.warning("segment %d not found, but listed in compaction data", segment)
                 del self.compact[segment]
                 pi.show()
                 continue
@@ -808,13 +825,22 @@ class Repository:
             # we want to compact if:
             # - we can free a considerable relative amount of space (freeable_ratio over some threshold)
             if not (freeable_ratio > threshold):
-                logger.debug('not compacting segment %d (maybe freeable: %2.2f%% [%d bytes])',
-                             segment, freeable_ratio * 100.0, freeable_space)
+                logger.debug(
+                    "not compacting segment %d (maybe freeable: %2.2f%% [%d bytes])",
+                    segment,
+                    freeable_ratio * 100.0,
+                    freeable_space,
+                )
                 pi.show()
                 continue
             segments.setdefault(segment, 0)
-            logger.debug('compacting segment %d with usage count %d (maybe freeable: %2.2f%% [%d bytes])',
-                         segment, segments[segment], freeable_ratio * 100.0, freeable_space)
+            logger.debug(
+                "compacting segment %d with usage count %d (maybe freeable: %2.2f%% [%d bytes])",
+                segment,
+                segments[segment],
+                freeable_ratio * 100.0,
+                freeable_space,
+            )
             for tag, key, offset, data in self.io.iter_objects(segment, include_data=True):
                 if tag == TAG_COMMIT:
                     continue
@@ -849,7 +875,9 @@ class Repository:
                     shadowed_put_exists = key not in self.shadow_index or any(
                         # If the key is in the shadow index and there is any segment with an older PUT of this
                         # key, we have a shadowed put.
-                        shadowed < segment for shadowed in self.shadow_index[key])
+                        shadowed < segment
+                        for shadowed in self.shadow_index[key]
+                    )
                     delete_is_not_stable = index_transaction_id is None or segment > index_transaction_id
 
                     if shadowed_put_exists or delete_is_not_stable:
@@ -898,14 +926,14 @@ class Repository:
                         if not self.shadow_index[key]:
                             # shadowed segments list is empty -> remove it
                             del self.shadow_index[key]
-            assert segments[segment] == 0, 'Corrupted segment reference count - corrupted index or hints'
+            assert segments[segment] == 0, "Corrupted segment reference count - corrupted index or hints"
             unused.append(segment)
             pi.show()
         pi.finish()
         complete_xfer(intermediate=False)
         quota_use_after = self.storage_quota_use
-        logger.info('compaction freed about %s repository space.', format_file_size(quota_use_before - quota_use_after))
-        logger.debug('compaction completed.')
+        logger.info("compaction freed about %s repository space.", format_file_size(quota_use_before - quota_use_after))
+        logger.debug("compaction completed.")
 
     def replay_segments(self, index_transaction_id, segments_transaction_id):
         # fake an old client, so that in case we do not have an exclusive lock yet, prepare_txn will upgrade the lock:
@@ -914,8 +942,9 @@ class Repository:
         self.prepare_txn(index_transaction_id, do_cleanup=False)
         try:
             segment_count = sum(1 for _ in self.io.segment_iterator())
-            pi = ProgressIndicatorPercent(total=segment_count, msg='Replaying segments %3.0f%%',
-                                          msgid='repository.replay_segments')
+            pi = ProgressIndicatorPercent(
+                total=segment_count, msg="Replaying segments %3.0f%%", msgid="repository.replay_segments"
+            )
             for i, (segment, filename) in enumerate(self.io.segment_iterator()):
                 pi.show(i)
                 if index_transaction_id is not None and segment <= index_transaction_id:
@@ -960,7 +989,7 @@ class Repository:
             elif tag == TAG_COMMIT:
                 continue
             else:
-                msg = f'Unexpected tag {tag} in segment {segment}'
+                msg = f"Unexpected tag {tag} in segment {segment}"
                 if report is None:
                     raise self.CheckNeeded(msg)
                 else:
@@ -1008,56 +1037,57 @@ class Repository:
             error_found = True
             logger.error(msg)
 
-        logger.info('Starting repository check')
+        logger.info("Starting repository check")
         assert not self._active_txn
         try:
             transaction_id = self.get_transaction_id()
             current_index = self.open_index(transaction_id)
-            logger.debug('Read committed index of transaction %d', transaction_id)
+            logger.debug("Read committed index of transaction %d", transaction_id)
         except Exception as exc:
             transaction_id = self.io.get_segments_transaction_id()
             current_index = None
-            logger.debug('Failed to read committed index (%s)', exc)
+            logger.debug("Failed to read committed index (%s)", exc)
         if transaction_id is None:
-            logger.debug('No segments transaction found')
+            logger.debug("No segments transaction found")
             transaction_id = self.get_index_transaction_id()
         if transaction_id is None:
-            logger.debug('No index transaction found, trying latest segment')
+            logger.debug("No index transaction found, trying latest segment")
             transaction_id = self.io.get_latest_segment()
         if transaction_id is None:
-            report_error('This repository contains no valid data.')
+            report_error("This repository contains no valid data.")
             return False
         if repair:
             self.io.cleanup(transaction_id)
         segments_transaction_id = self.io.get_segments_transaction_id()
-        logger.debug('Segment transaction is    %s', segments_transaction_id)
-        logger.debug('Determined transaction is %s', transaction_id)
+        logger.debug("Segment transaction is    %s", segments_transaction_id)
+        logger.debug("Determined transaction is %s", transaction_id)
         self.prepare_txn(None)  # self.index, self.compact, self.segments, self.shadow_index all empty now!
         segment_count = sum(1 for _ in self.io.segment_iterator())
-        logger.debug('Found %d segments', segment_count)
+        logger.debug("Found %d segments", segment_count)
 
         partial = bool(max_duration)
         assert not (repair and partial)
-        mode = 'partial' if partial else 'full'
+        mode = "partial" if partial else "full"
         if partial:
             # continue a past partial check (if any) or start one from beginning
-            last_segment_checked = self.config.getint('repository', 'last_segment_checked', fallback=-1)
-            logger.info('skipping to segments >= %d', last_segment_checked + 1)
+            last_segment_checked = self.config.getint("repository", "last_segment_checked", fallback=-1)
+            logger.info("skipping to segments >= %d", last_segment_checked + 1)
         else:
             # start from the beginning and also forget about any potential past partial checks
             last_segment_checked = -1
-            self.config.remove_option('repository', 'last_segment_checked')
+            self.config.remove_option("repository", "last_segment_checked")
             self.save_config(self.path, self.config)
         t_start = time.monotonic()
-        pi = ProgressIndicatorPercent(total=segment_count, msg='Checking segments %3.1f%%', step=0.1,
-                                      msgid='repository.check')
+        pi = ProgressIndicatorPercent(
+            total=segment_count, msg="Checking segments %3.1f%%", step=0.1, msgid="repository.check"
+        )
         for i, (segment, filename) in enumerate(self.io.segment_iterator()):
             pi.show(i)
             if segment <= last_segment_checked:
                 continue
             if segment > transaction_id:
                 continue
-            logger.debug('checking segment file %s...', filename)
+            logger.debug("checking segment file %s...", filename)
             try:
                 objects = list(self.io.iter_objects(segment))
             except IntegrityError as err:
@@ -1069,35 +1099,35 @@ class Repository:
             if not partial:
                 self._update_index(segment, objects, report_error)
             if partial and time.monotonic() > t_start + max_duration:
-                logger.info('finished partial segment check, last segment checked is %d', segment)
-                self.config.set('repository', 'last_segment_checked', str(segment))
+                logger.info("finished partial segment check, last segment checked is %d", segment)
+                self.config.set("repository", "last_segment_checked", str(segment))
                 self.save_config(self.path, self.config)
                 break
         else:
-            logger.info('finished segment check at segment %d', segment)
-            self.config.remove_option('repository', 'last_segment_checked')
+            logger.info("finished segment check at segment %d", segment)
+            self.config.remove_option("repository", "last_segment_checked")
             self.save_config(self.path, self.config)
 
         pi.finish()
         # self.index, self.segments, self.compact now reflect the state of the segment files up to <transaction_id>
         # We might need to add a commit tag if no committed segment is found
         if repair and segments_transaction_id is None:
-            report_error(f'Adding commit tag to segment {transaction_id}')
+            report_error(f"Adding commit tag to segment {transaction_id}")
             self.io.segment = transaction_id + 1
             self.io.write_commit()
         if not partial:
-            logger.info('Starting repository index check')
+            logger.info("Starting repository index check")
             if current_index and not repair:
                 # current_index = "as found on disk"
                 # self.index = "as rebuilt in-memory from segments"
                 if len(current_index) != len(self.index):
-                    report_error('Index object count mismatch.')
-                    logger.error('committed index: %d objects', len(current_index))
-                    logger.error('rebuilt index:   %d objects', len(self.index))
+                    report_error("Index object count mismatch.")
+                    logger.error("committed index: %d objects", len(current_index))
+                    logger.error("rebuilt index:   %d objects", len(self.index))
                 else:
-                    logger.info('Index object count match.')
-                line_format = 'ID: %-64s rebuilt index: %-16s committed index: %-16s'
-                not_found = '<not found>'
+                    logger.info("Index object count match.")
+                line_format = "ID: %-64s rebuilt index: %-16s committed index: %-16s"
+                not_found = "<not found>"
                 for key, value in self.index.iteritems():
                     current_value = current_index.get(key, not_found)
                     if current_value != value:
@@ -1113,11 +1143,11 @@ class Repository:
         self.rollback()
         if error_found:
             if repair:
-                logger.info('Finished %s repository check, errors found and repaired.', mode)
+                logger.info("Finished %s repository check, errors found and repaired.", mode)
             else:
-                logger.error('Finished %s repository check, errors found.', mode)
+                logger.error("Finished %s repository check, errors found.", mode)
         else:
-            logger.info('Finished %s repository check, no problems found.', mode)
+            logger.info("Finished %s repository check, no problems found.", mode)
         return not error_found or repair
 
     def scan_low_level(self, segment=None, offset=None):
@@ -1136,18 +1166,19 @@ class Repository:
             if segment is not None and current_segment > segment:
                 break
             try:
-                for tag, key, current_offset, data in self.io.iter_objects(segment=current_segment,
-                                                                           offset=offset or 0, include_data=True):
+                for tag, key, current_offset, data in self.io.iter_objects(
+                    segment=current_segment, offset=offset or 0, include_data=True
+                ):
                     if offset is not None and current_offset > offset:
                         break
                     yield key, data, tag, current_segment, current_offset
             except IntegrityError as err:
-                logger.error('Segment %d (%s) has IntegrityError(s) [%s] - skipping.' % (
-                             current_segment, filename, str(err)))
+                logger.error(
+                    "Segment %d (%s) has IntegrityError(s) [%s] - skipping." % (current_segment, filename, str(err))
+                )
 
     def _rollback(self, *, cleanup):
-        """
-        """
+        """ """
         if cleanup:
             self.io.cleanup(self.io.get_segments_transaction_id())
         self.index = None
@@ -1189,7 +1220,7 @@ class Repository:
           if we encounter CRC errors in segment entry headers, rest of segment is skipped.
         """
         if limit is not None and limit < 1:
-            raise ValueError('please use limit > 0 or limit = None')
+            raise ValueError("please use limit > 0 or limit = None")
         if not self.index:
             transaction_id = self.get_transaction_id()
             self.index = self.open_index(transaction_id)
@@ -1225,7 +1256,7 @@ class Repository:
         if not self.index:
             self.index = self.open_index(self.get_transaction_id())
         try:
-            in_index = NSIndexEntry(*((self.index[id] + (None, ))[:3]))  # legacy: index entriess have no size element
+            in_index = NSIndexEntry(*((self.index[id] + (None,))[:3]))  # legacy: index entriess have no size element
             return self.io.read(in_index.segment, in_index.offset, id, expected_size=in_index.size)
         except KeyError:
             raise self.ObjectNotFound(id, self.path) from None
@@ -1259,7 +1290,8 @@ class Repository:
         self.index[id] = NSIndexEntry(segment, offset, len(data))
         if self.storage_quota and self.storage_quota_use > self.storage_quota:
             self.transaction_doomed = self.StorageQuotaExceeded(
-                format_file_size(self.storage_quota), format_file_size(self.storage_quota_use))
+                format_file_size(self.storage_quota), format_file_size(self.storage_quota_use)
+            )
             raise self.transaction_doomed
 
     def delete(self, id, wait=True):
@@ -1302,20 +1334,18 @@ class Repository:
         """
 
     def preload(self, ids):
-        """Preload objects (only applies to remote repositories)
-        """
+        """Preload objects (only applies to remote repositories)"""
 
 
 class LoggedIO:
-
     class SegmentFull(Exception):
         """raised when a segment is full, before opening next"""
 
-    header_fmt = struct.Struct('<IIB')
+    header_fmt = struct.Struct("<IIB")
     assert header_fmt.size == 9
-    header_no_crc_fmt = struct.Struct('<IB')
+    header_no_crc_fmt = struct.Struct("<IB")
     assert header_no_crc_fmt.size == 5
-    crc_fmt = struct.Struct('<I')
+    crc_fmt = struct.Struct("<I")
     assert crc_fmt.size == 4
 
     _commit = header_no_crc_fmt.pack(9, TAG_COMMIT)
@@ -1341,13 +1371,13 @@ class LoggedIO:
 
     def _close_fd(self, ts_fd):
         ts, fd = ts_fd
-        safe_fadvise(fd.fileno(), 0, 0, 'DONTNEED')
+        safe_fadvise(fd.fileno(), 0, 0, "DONTNEED")
         fd.close()
 
     def segment_iterator(self, segment=None, reverse=False):
         if segment is None:
-            segment = 0 if not reverse else 2 ** 32 - 1
-        data_path = os.path.join(self.path, 'data')
+            segment = 0 if not reverse else 2**32 - 1
+        data_path = os.path.join(self.path, "data")
         start_segment_dir = segment // self.segments_per_dir
         dirs = os.listdir(data_path)
         if not reverse:
@@ -1373,16 +1403,14 @@ class LoggedIO:
         return None
 
     def get_segments_transaction_id(self):
-        """Return the last committed segment.
-        """
+        """Return the last committed segment."""
         for segment, filename in self.segment_iterator(reverse=True):
             if self.is_committed_segment(segment):
                 return segment
         return None
 
     def cleanup(self, transaction_id):
-        """Delete segment files left by aborted transactions
-        """
+        """Delete segment files left by aborted transactions"""
         self.segment = transaction_id + 1
         count = 0
         for segment, filename in self.segment_iterator(reverse=True):
@@ -1393,17 +1421,15 @@ class LoggedIO:
                 count += 1
             else:
                 break
-        logger.debug('Cleaned up %d uncommitted segment files (== everything after segment %d).',
-                     count, transaction_id)
+        logger.debug("Cleaned up %d uncommitted segment files (== everything after segment %d).", count, transaction_id)
 
     def is_committed_segment(self, segment):
-        """Check if segment ends with a COMMIT_TAG tag
-        """
+        """Check if segment ends with a COMMIT_TAG tag"""
         try:
             iterator = self.iter_objects(segment)
         except IntegrityError:
             return False
-        with open(self.segment_filename(segment), 'rb') as fd:
+        with open(self.segment_filename(segment), "rb") as fd:
             try:
                 fd.seek(-self.header_fmt.size, os.SEEK_END)
             except OSError as e:
@@ -1429,7 +1455,7 @@ class LoggedIO:
         return seen_commit
 
     def segment_filename(self, segment):
-        return os.path.join(self.path, 'data', str(segment // self.segments_per_dir), str(segment))
+        return os.path.join(self.path, "data", str(segment // self.segments_per_dir), str(segment))
 
     def get_write_fd(self, no_new=False, want_new=False, raise_full=False):
         if not no_new and (want_new or self.offset and self.offset > self.limit):
@@ -1438,10 +1464,10 @@ class LoggedIO:
             self.close_segment()
         if not self._write_fd:
             if self.segment % self.segments_per_dir == 0:
-                dirname = os.path.join(self.path, 'data', str(self.segment // self.segments_per_dir))
+                dirname = os.path.join(self.path, "data", str(self.segment // self.segments_per_dir))
                 if not os.path.exists(dirname):
                     os.mkdir(dirname)
-                    sync_dir(os.path.join(self.path, 'data'))
+                    sync_dir(os.path.join(self.path, "data"))
             self._write_fd = SyncFile(self.segment_filename(self.segment), binary=True)
             self._write_fd.write(MAGIC)
             self.offset = MAGIC_LEN
@@ -1459,7 +1485,7 @@ class LoggedIO:
         now = time.monotonic()
 
         def open_fd():
-            fd = open(self.segment_filename(segment), 'rb')
+            fd = open(self.segment_filename(segment), "rb")
             self.fds[segment] = (now, fd)
             return fd
 
@@ -1535,13 +1561,13 @@ class LoggedIO:
             # Repository.scan() calls us with segment > 0 when it continues an ongoing iteration
             # from a marker position - but then we have checked the magic before already.
             if fd.read(MAGIC_LEN) != MAGIC:
-                raise IntegrityError(f'Invalid segment magic [segment {segment}, offset {0}]')
+                raise IntegrityError(f"Invalid segment magic [segment {segment}, offset {0}]")
             offset = MAGIC_LEN
         header = fd.read(self.header_fmt.size)
         while header:
-            size, tag, key, data = self._read(fd, header, segment, offset,
-                                              (TAG_PUT2, TAG_DELETE, TAG_COMMIT, TAG_PUT),
-                                              read_data=read_data)
+            size, tag, key, data = self._read(
+                fd, header, segment, offset, (TAG_PUT2, TAG_DELETE, TAG_COMMIT, TAG_PUT), read_data=read_data
+            )
             if include_data:
                 yield tag, key, offset, data
             else:
@@ -1558,7 +1584,7 @@ class LoggedIO:
             header = fd.read(self.header_fmt.size)
 
     def recover_segment(self, segment, filename):
-        logger.info('attempting to recover ' + filename)
+        logger.info("attempting to recover " + filename)
         if segment in self.fds:
             del self.fds[segment]
         if os.path.getsize(filename) < MAGIC_LEN + self.header_fmt.size:
@@ -1568,7 +1594,7 @@ class LoggedIO:
                 fd.write(MAGIC)
             return
         with SaveFile(filename, binary=True) as dst_fd:
-            with open(filename, 'rb') as src_fd:
+            with open(filename, "rb") as src_fd:
                 # note: file must not be 0 size or mmap() will crash.
                 with mmap.mmap(src_fd.fileno(), 0, access=mmap.ACCESS_READ) as mm:
                     # memoryview context manager is problematic, see https://bugs.python.org/issue35686
@@ -1577,7 +1603,7 @@ class LoggedIO:
                     try:
                         dst_fd.write(MAGIC)
                         while len(d) >= self.header_fmt.size:
-                            crc, size, tag = self.header_fmt.unpack(d[:self.header_fmt.size])
+                            crc, size, tag = self.header_fmt.unpack(d[: self.header_fmt.size])
                             size_invalid = size > MAX_OBJECT_SIZE or size < self.header_fmt.size or size > len(d)
                             if size_invalid or tag > MAX_TAG_ID:
                                 d = d[1:]
@@ -1585,15 +1611,18 @@ class LoggedIO:
                             if tag == TAG_PUT2:
                                 c_offset = self.HEADER_ID_SIZE + self.ENTRY_HASH_SIZE
                                 # skip if header is invalid
-                                if crc32(d[4:c_offset]) & 0xffffffff != crc:
+                                if crc32(d[4:c_offset]) & 0xFFFFFFFF != crc:
                                     d = d[1:]
                                     continue
                                 # skip if content is invalid
-                                if self.entry_hash(d[4:self.HEADER_ID_SIZE], d[c_offset:size]) != d[self.HEADER_ID_SIZE:c_offset]:
+                                if (
+                                    self.entry_hash(d[4 : self.HEADER_ID_SIZE], d[c_offset:size])
+                                    != d[self.HEADER_ID_SIZE : c_offset]
+                                ):
                                     d = d[1:]
                                     continue
                             elif tag in (TAG_DELETE, TAG_COMMIT, TAG_PUT):
-                                if crc32(d[4:size]) & 0xffffffff != crc:
+                                if crc32(d[4:size]) & 0xFFFFFFFF != crc:
                                     d = d[1:]
                                     continue
                             else:  # tag unknown
@@ -1625,12 +1654,14 @@ class LoggedIO:
         header = fd.read(self.header_fmt.size)
         size, tag, key, data = self._read(fd, header, segment, offset, (TAG_PUT2, TAG_PUT), read_data)
         if id != key:
-            raise IntegrityError('Invalid segment entry header, is not for wanted id [segment {}, offset {}]'.format(
-                segment, offset))
+            raise IntegrityError(
+                "Invalid segment entry header, is not for wanted id [segment {}, offset {}]".format(segment, offset)
+            )
         data_size_from_header = size - header_size(tag)
         if expected_size is not None and expected_size != data_size_from_header:
-            raise IntegrityError(f'size from repository index: {expected_size} != '
-                                 f'size from entry header: {data_size_from_header}')
+            raise IntegrityError(
+                f"size from repository index: {expected_size} != " f"size from entry header: {data_size_from_header}"
+            )
         return data if read_data else data_size_from_header
 
     def _read(self, fd, header, segment, offset, acceptable_tags, read_data=True):
@@ -1643,35 +1674,38 @@ class LoggedIO:
         PUT tags, read_data == True: crc32 check (header+data)
         PUT tags, read_data == False: crc32 check can not be done, all data obtained must be considered informational
         """
+
         def check_crc32(wanted, header, *data):
             result = crc32(memoryview(header)[4:])  # skip first 32 bits of the header, they contain the crc.
             for d in data:
                 result = crc32(d, result)
-            if result & 0xffffffff != wanted:
-                raise IntegrityError(f'Segment entry header checksum mismatch [segment {segment}, offset {offset}]')
+            if result & 0xFFFFFFFF != wanted:
+                raise IntegrityError(f"Segment entry header checksum mismatch [segment {segment}, offset {offset}]")
 
         # See comment on MAX_TAG_ID for details
-        assert max(acceptable_tags) <= MAX_TAG_ID, 'Exceeding MAX_TAG_ID will break backwards compatibility'
+        assert max(acceptable_tags) <= MAX_TAG_ID, "Exceeding MAX_TAG_ID will break backwards compatibility"
         key = data = None
         fmt = self.header_fmt
         try:
             hdr_tuple = fmt.unpack(header)
         except struct.error as err:
-            raise IntegrityError(f'Invalid segment entry header [segment {segment}, offset {offset}]: {err}') from None
+            raise IntegrityError(f"Invalid segment entry header [segment {segment}, offset {offset}]: {err}") from None
         crc, size, tag = hdr_tuple
         length = size - fmt.size  # we already read the header
         if size > MAX_OBJECT_SIZE:
             # if you get this on an archive made with borg < 1.0.7 and millions of files and
             # you need to restore it, you can disable this check by using "if False:" above.
-            raise IntegrityError(f'Invalid segment entry size {size} - too big [segment {segment}, offset {offset}]')
+            raise IntegrityError(f"Invalid segment entry size {size} - too big [segment {segment}, offset {offset}]")
         if size < fmt.size:
-            raise IntegrityError(f'Invalid segment entry size {size} - too small [segment {segment}, offset {offset}]')
+            raise IntegrityError(f"Invalid segment entry size {size} - too small [segment {segment}, offset {offset}]")
         if tag not in (TAG_PUT2, TAG_DELETE, TAG_COMMIT, TAG_PUT):
-            raise IntegrityError(f'Invalid segment entry header, did not get a known tag '
-                                 f'[segment {segment}, offset {offset}]')
+            raise IntegrityError(
+                f"Invalid segment entry header, did not get a known tag " f"[segment {segment}, offset {offset}]"
+            )
         if tag not in acceptable_tags:
-            raise IntegrityError(f'Invalid segment entry header, did not get acceptable tag '
-                                 f'[segment {segment}, offset {offset}]')
+            raise IntegrityError(
+                f"Invalid segment entry header, did not get acceptable tag " f"[segment {segment}, offset {offset}]"
+            )
         if tag == TAG_COMMIT:
             check_crc32(crc, header)
             # that's all for COMMITs.
@@ -1680,8 +1714,10 @@ class LoggedIO:
             key = fd.read(32)
             length -= 32
             if len(key) != 32:
-                raise IntegrityError(f'Segment entry key short read [segment {segment}, offset {offset}]: '
-                                     f'expected {32}, got {len(key)} bytes')
+                raise IntegrityError(
+                    f"Segment entry key short read [segment {segment}, offset {offset}]: "
+                    f"expected {32}, got {len(key)} bytes"
+                )
             if tag == TAG_DELETE:
                 check_crc32(crc, header, key)
                 # that's all for DELETEs.
@@ -1692,23 +1728,29 @@ class LoggedIO:
                     entry_hash = fd.read(self.ENTRY_HASH_SIZE)
                     length -= self.ENTRY_HASH_SIZE
                     if len(entry_hash) != self.ENTRY_HASH_SIZE:
-                        raise IntegrityError(f'Segment entry hash short read [segment {segment}, offset {offset}]: '
-                                             f'expected {self.ENTRY_HASH_SIZE}, got {len(entry_hash)} bytes')
+                        raise IntegrityError(
+                            f"Segment entry hash short read [segment {segment}, offset {offset}]: "
+                            f"expected {self.ENTRY_HASH_SIZE}, got {len(entry_hash)} bytes"
+                        )
                     check_crc32(crc, header, key, entry_hash)
                 if not read_data:  # seek over data
                     oldpos = fd.tell()
                     seeked = fd.seek(length, os.SEEK_CUR) - oldpos
                     if seeked != length:
-                        raise IntegrityError(f'Segment entry data short seek [segment {segment}, offset {offset}]: '
-                                             f'expected {length}, got {seeked} bytes')
+                        raise IntegrityError(
+                            f"Segment entry data short seek [segment {segment}, offset {offset}]: "
+                            f"expected {length}, got {seeked} bytes"
+                        )
                 else:  # read data!
                     data = fd.read(length)
                     if len(data) != length:
-                        raise IntegrityError(f'Segment entry data short read [segment {segment}, offset {offset}]: '
-                                             f'expected {length}, got {len(data)} bytes')
+                        raise IntegrityError(
+                            f"Segment entry data short read [segment {segment}, offset {offset}]: "
+                            f"expected {length}, got {len(data)} bytes"
+                        )
                     if tag == TAG_PUT2:
                         if self.entry_hash(memoryview(header)[4:], key, data) != entry_hash:
-                            raise IntegrityError(f'Segment entry hash mismatch [segment {segment}, offset {offset}]')
+                            raise IntegrityError(f"Segment entry hash mismatch [segment {segment}, offset {offset}]")
                     elif tag == TAG_PUT:
                         check_crc32(crc, header, key, data)
         return size, tag, key, data
@@ -1717,14 +1759,14 @@ class LoggedIO:
         data_size = len(data)
         if data_size > MAX_DATA_SIZE:
             # this would push the segment entry size beyond MAX_OBJECT_SIZE.
-            raise IntegrityError(f'More than allowed put data [{data_size} > {MAX_DATA_SIZE}]')
+            raise IntegrityError(f"More than allowed put data [{data_size} > {MAX_DATA_SIZE}]")
         fd = self.get_write_fd(want_new=(id == Manifest.MANIFEST_ID), raise_full=raise_full)
         size = data_size + self.HEADER_ID_SIZE + self.ENTRY_HASH_SIZE
         offset = self.offset
         header = self.header_no_crc_fmt.pack(size, TAG_PUT2)
         entry_hash = self.entry_hash(header, id, data)
-        crc = self.crc_fmt.pack(crc32(entry_hash, crc32(id, crc32(header))) & 0xffffffff)
-        fd.write(b''.join((crc, header, id, entry_hash)))
+        crc = self.crc_fmt.pack(crc32(entry_hash, crc32(id, crc32(header))) & 0xFFFFFFFF)
+        fd.write(b"".join((crc, header, id, entry_hash)))
         fd.write(data)
         self.offset += size
         return self.segment, offset
@@ -1732,8 +1774,8 @@ class LoggedIO:
     def write_delete(self, id, raise_full=False):
         fd = self.get_write_fd(want_new=(id == Manifest.MANIFEST_ID), raise_full=raise_full)
         header = self.header_no_crc_fmt.pack(self.HEADER_ID_SIZE, TAG_DELETE)
-        crc = self.crc_fmt.pack(crc32(id, crc32(header)) & 0xffffffff)
-        fd.write(b''.join((crc, header, id)))
+        crc = self.crc_fmt.pack(crc32(id, crc32(header)) & 0xFFFFFFFF)
+        fd.write(b"".join((crc, header, id)))
         self.offset += self.HEADER_ID_SIZE
         return self.segment, self.HEADER_ID_SIZE
 
@@ -1744,8 +1786,8 @@ class LoggedIO:
         if intermediate:
             fd.sync()
         header = self.header_no_crc_fmt.pack(self.header_fmt.size, TAG_COMMIT)
-        crc = self.crc_fmt.pack(crc32(header) & 0xffffffff)
-        fd.write(b''.join((crc, header)))
+        crc = self.crc_fmt.pack(crc32(header) & 0xFFFFFFFF)
+        fd.write(b"".join((crc, header)))
         self.close_segment()
         return self.segment - 1  # close_segment() increments it
 
diff --git a/src/borg/selftest.py b/src/borg/selftest.py
index 1bef011c2..49a9704c2 100644
--- a/src/borg/selftest.py
+++ b/src/borg/selftest.py
@@ -50,16 +50,16 @@ class SelfTestResult(TestResult):
 
     def log_results(self, logger):
         for test, failure in self.errors + self.failures + self.unexpectedSuccesses:
-            logger.error('self test %s FAILED:\n%s', self.test_name(test), failure)
+            logger.error("self test %s FAILED:\n%s", self.test_name(test), failure)
         for test, reason in self.skipped:
-            logger.warning('self test %s skipped: %s', self.test_name(test), reason)
+            logger.warning("self test %s skipped: %s", self.test_name(test), reason)
 
     def successful_test_count(self):
         return len(self.successes)
 
 
 def selftest(logger):
-    if os.environ.get('BORG_SELFTEST') == 'disabled':
+    if os.environ.get("BORG_SELFTEST") == "disabled":
         logger.debug("borg selftest disabled via BORG_SELFTEST env variable")
         return
     selftest_started = time.perf_counter()
@@ -69,7 +69,7 @@ def selftest(logger):
         module = sys.modules[test_case.__module__]
         # a normal borg user does not have pytest installed, we must not require it in the test modules used here.
         # note: this only detects the usual toplevel import
-        assert 'pytest' not in dir(module), "pytest must not be imported in %s" % module.__name__
+        assert "pytest" not in dir(module), "pytest must not be imported in %s" % module.__name__
         test_suite.addTest(defaultTestLoader.loadTestsFromTestCase(test_case))
     test_suite.run(result)
     result.log_results(logger)
@@ -77,12 +77,17 @@ def selftest(logger):
     count_mismatch = successful_tests != SELFTEST_COUNT
     if result.wasSuccessful() and count_mismatch:
         # only print this if all tests succeeded
-        logger.error("self test count (%d != %d) mismatch, either test discovery is broken or a test was added "
-                     "without updating borg.selftest",
-                     successful_tests, SELFTEST_COUNT)
+        logger.error(
+            "self test count (%d != %d) mismatch, either test discovery is broken or a test was added "
+            "without updating borg.selftest",
+            successful_tests,
+            SELFTEST_COUNT,
+        )
     if not result.wasSuccessful() or count_mismatch:
-        logger.error("self test failed\n"
-                     "Could be a bug either in Borg, the package / distribution you use, your OS or your hardware.")
+        logger.error(
+            "self test failed\n"
+            "Could be a bug either in Borg, the package / distribution you use, your OS or your hardware."
+        )
         sys.exit(2)
         assert False, "sanity assertion failed: ran beyond sys.exit()"
     selftest_elapsed = time.perf_counter() - selftest_started
diff --git a/src/borg/shellpattern.py b/src/borg/shellpattern.py
index c9447704b..7427a4c89 100644
--- a/src/borg/shellpattern.py
+++ b/src/borg/shellpattern.py
@@ -33,7 +33,7 @@ def translate(pat, match_end=r"\Z"):
             if i + 1 < n and pat[i] == "*" and pat[i + 1] == sep:
                 # **/ == wildcard for 0+ full (relative) directory names with trailing slashes; the forward slash stands
                 # for the platform-specific path separator
-                res += fr"(?:[^\{sep}]*\{sep})*"
+                res += rf"(?:[^\{sep}]*\{sep})*"
                 i += 2
             else:
                 # * == wildcard for name parts (does not cross path separator)
diff --git a/src/borg/testsuite/__init__.py b/src/borg/testsuite/__init__.py
index 0ad942482..c98fd5968 100644
--- a/src/borg/testsuite/__init__.py
+++ b/src/borg/testsuite/__init__.py
@@ -2,6 +2,7 @@ from contextlib import contextmanager
 import filecmp
 import functools
 import os
+
 try:
     import posix
 except ImportError:
@@ -25,14 +26,14 @@ from .. import platform
 from ..fuse_impl import llfuse, has_pyfuse3, has_llfuse
 
 # Does this version of llfuse support ns precision?
-have_fuse_mtime_ns = hasattr(llfuse.EntryAttributes, 'st_mtime_ns') if llfuse else False
+have_fuse_mtime_ns = hasattr(llfuse.EntryAttributes, "st_mtime_ns") if llfuse else False
 
 try:
     from pytest import raises
 except:  # noqa
     raises = None
 
-has_lchflags = hasattr(os, 'lchflags') or sys.platform.startswith('linux')
+has_lchflags = hasattr(os, "lchflags") or sys.platform.startswith("linux")
 try:
     with tempfile.NamedTemporaryFile() as file:
         platform.set_flags(file.name, stat.UF_NODUMP)
@@ -40,14 +41,14 @@ except OSError:
     has_lchflags = False
 
 # The mtime get/set precision varies on different OS and Python versions
-if posix and 'HAVE_FUTIMENS' in getattr(posix, '_have_functions', []):
+if posix and "HAVE_FUTIMENS" in getattr(posix, "_have_functions", []):
     st_mtime_ns_round = 0
-elif 'HAVE_UTIMES' in sysconfig.get_config_vars():
+elif "HAVE_UTIMES" in sysconfig.get_config_vars():
     st_mtime_ns_round = -6
 else:
     st_mtime_ns_round = -9
 
-if sys.platform.startswith('netbsd'):
+if sys.platform.startswith("netbsd"):
     st_mtime_ns_round = -4  # only >1 microsecond resolution here?
 
 
@@ -61,8 +62,8 @@ def unopened_tempfile():
 def are_symlinks_supported():
     with unopened_tempfile() as filepath:
         try:
-            os.symlink('somewhere', filepath)
-            if os.stat(filepath, follow_symlinks=False) and os.readlink(filepath) == 'somewhere':
+            os.symlink("somewhere", filepath)
+            if os.stat(filepath, follow_symlinks=False) and os.readlink(filepath) == "somewhere":
                 return True
         except OSError:
             pass
@@ -71,12 +72,12 @@ def are_symlinks_supported():
 
 @functools.lru_cache
 def are_hardlinks_supported():
-    if not hasattr(os, 'link'):
+    if not hasattr(os, "link"):
         # some pythons do not have os.link
         return False
 
     with unopened_tempfile() as file1path, unopened_tempfile() as file2path:
-        open(file1path, 'w').close()
+        open(file1path, "w").close()
         try:
             os.link(file1path, file2path)
             stat1 = os.stat(file1path)
@@ -108,9 +109,9 @@ def is_utime_fully_supported():
     with unopened_tempfile() as filepath:
         # Some filesystems (such as SSHFS) don't support utime on symlinks
         if are_symlinks_supported():
-            os.symlink('something', filepath)
+            os.symlink("something", filepath)
         else:
-            open(filepath, 'w').close()
+            open(filepath, "w").close()
         try:
             os.utime(filepath, (1000, 2000), follow_symlinks=False)
             new_stats = os.stat(filepath, follow_symlinks=False)
@@ -125,14 +126,14 @@ def is_utime_fully_supported():
 
 @functools.lru_cache
 def is_birthtime_fully_supported():
-    if not hasattr(os.stat_result, 'st_birthtime'):
+    if not hasattr(os.stat_result, "st_birthtime"):
         return False
     with unopened_tempfile() as filepath:
         # Some filesystems (such as SSHFS) don't support utime on symlinks
         if are_symlinks_supported():
-            os.symlink('something', filepath)
+            os.symlink("something", filepath)
         else:
-            open(filepath, 'w').close()
+            open(filepath, "w").close()
         try:
             birthtime, mtime, atime = 946598400, 946684800, 946771200
             os.utime(filepath, (atime, birthtime), follow_symlinks=False)
@@ -149,7 +150,7 @@ def is_birthtime_fully_supported():
 
 def no_selinux(x):
     # selinux fails our FUSE tests, thus ignore selinux xattrs
-    SELINUX_KEY = b'security.selinux'
+    SELINUX_KEY = b"security.selinux"
     if isinstance(x, dict):
         return {k: v for k, v in x.items() if k != SELINUX_KEY}
     if isinstance(x, list):
@@ -157,8 +158,8 @@ def no_selinux(x):
 
 
 class BaseTestCase(unittest.TestCase):
-    """
-    """
+    """ """
+
     assert_in = unittest.TestCase.assertIn
     assert_not_in = unittest.TestCase.assertNotIn
     assert_equal = unittest.TestCase.assertEqual
@@ -171,9 +172,9 @@ class BaseTestCase(unittest.TestCase):
 
     @contextmanager
     def assert_creates_file(self, path):
-        assert not os.path.exists(path), f'{path} should not exist'
+        assert not os.path.exists(path), f"{path} should not exist"
         yield
-        assert os.path.exists(path), f'{path} should exist'
+        assert os.path.exists(path), f"{path} should exist"
 
     def assert_dirs_equal(self, dir1, dir2, **kwargs):
         diff = filecmp.dircmp(dir1, dir2)
@@ -191,10 +192,10 @@ class BaseTestCase(unittest.TestCase):
             s2 = os.stat(path2, follow_symlinks=False)
             # Assume path2 is on FUSE if st_dev is different
             fuse = s1.st_dev != s2.st_dev
-            attrs = ['st_uid', 'st_gid', 'st_rdev']
+            attrs = ["st_uid", "st_gid", "st_rdev"]
             if not fuse or not os.path.isdir(path1):
                 # dir nlink is always 1 on our FUSE filesystem
-                attrs.append('st_nlink')
+                attrs.append("st_nlink")
             d1 = [filename] + [getattr(s1, a) for a in attrs]
             d2 = [filename] + [getattr(s2, a) for a in attrs]
             d1.insert(1, oct(s1.st_mode))
@@ -225,7 +226,9 @@ class BaseTestCase(unittest.TestCase):
                 d2.append(no_selinux(get_all(path2, follow_symlinks=False)))
             self.assert_equal(d1, d2)
         for sub_diff in diff.subdirs.values():
-            self._assert_dirs_equal_cmp(sub_diff, ignore_flags=ignore_flags, ignore_xattrs=ignore_xattrs, ignore_ns=ignore_ns)
+            self._assert_dirs_equal_cmp(
+                sub_diff, ignore_flags=ignore_flags, ignore_xattrs=ignore_xattrs, ignore_ns=ignore_ns
+            )
 
     @contextmanager
     def fuse_mount(self, location, mountpoint=None, *options, fork=True, os_fork=False, **kwargs):
@@ -247,7 +250,7 @@ class BaseTestCase(unittest.TestCase):
             mountpoint = tempfile.mkdtemp()
         else:
             os.mkdir(mountpoint)
-        args = [f'--repo={location}', 'mount', mountpoint] + list(options)
+        args = [f"--repo={location}", "mount", mountpoint] + list(options)
         if os_fork:
             # Do not spawn, but actually (OS) fork.
             if os.fork() == 0:
@@ -264,12 +267,11 @@ class BaseTestCase(unittest.TestCase):
                     # This should never be reached, since it daemonizes,
                     # and the grandchild process exits before cmd() returns.
                     # However, just in case...
-                    print('Fatal: borg mount did not daemonize properly. Force exiting.',
-                          file=sys.stderr, flush=True)
+                    print("Fatal: borg mount did not daemonize properly. Force exiting.", file=sys.stderr, flush=True)
                     os._exit(0)
         else:
             self.cmd(*args, fork=fork, **kwargs)
-            if kwargs.get('exit_code', EXIT_SUCCESS) == EXIT_ERROR:
+            if kwargs.get("exit_code", EXIT_SUCCESS) == EXIT_ERROR:
                 # If argument `exit_code = EXIT_ERROR`, then this call
                 # is testing the behavior of an unsuccessful mount and
                 # we must not continue, as there is no mount to work
@@ -292,7 +294,7 @@ class BaseTestCase(unittest.TestCase):
             if os.path.ismount(mountpoint) == mounted:
                 return
             time.sleep(0.1)
-        message = 'Waiting for {} of {}'.format('mount' if mounted else 'umount', mountpoint)
+        message = "Waiting for {} of {}".format("mount" if mounted else "umount", mountpoint)
         raise TimeoutError(message)
 
     @contextmanager
@@ -308,17 +310,17 @@ class BaseTestCase(unittest.TestCase):
         tests are running with root privileges. Instead, the folder is
         rendered immutable with chattr or chflags, respectively.
         """
-        if sys.platform.startswith('linux'):
+        if sys.platform.startswith("linux"):
             cmd_immutable = 'chattr +i "%s"' % path
             cmd_mutable = 'chattr -i "%s"' % path
-        elif sys.platform.startswith(('darwin', 'freebsd', 'netbsd', 'openbsd')):
+        elif sys.platform.startswith(("darwin", "freebsd", "netbsd", "openbsd")):
             cmd_immutable = 'chflags uchg "%s"' % path
             cmd_mutable = 'chflags nouchg "%s"' % path
-        elif sys.platform.startswith('sunos'):  # openindiana
+        elif sys.platform.startswith("sunos"):  # openindiana
             cmd_immutable = 'chmod S+vimmutable "%s"' % path
             cmd_mutable = 'chmod S-vimmutable "%s"' % path
         else:
-            message = 'Testing read-only repos is not supported on platform %s' % sys.platform
+            message = "Testing read-only repos is not supported on platform %s" % sys.platform
             self.skipTest(message)
         try:
             os.system('LD_PRELOAD= chmod -R ugo-w "%s"' % path)
@@ -365,12 +367,13 @@ class environment_variable:
 
 class FakeInputs:
     """Simulate multiple user inputs, can be used as input() replacement"""
+
     def __init__(self, inputs):
         self.inputs = inputs
 
     def __call__(self, prompt=None):
         if prompt is not None:
-            print(prompt, end='')
+            print(prompt, end="")
         try:
             return self.inputs.pop(0)
         except IndexError:
diff --git a/src/borg/testsuite/archive.py b/src/borg/testsuite/archive.py
index cf19a5821..4eef5413f 100644
--- a/src/borg/testsuite/archive.py
+++ b/src/borg/testsuite/archive.py
@@ -33,64 +33,66 @@ def test_stats_basic(stats):
 
 
 def tests_stats_progress(stats, monkeypatch, columns=80):
-    monkeypatch.setenv('COLUMNS', str(columns))
+    monkeypatch.setenv("COLUMNS", str(columns))
     out = StringIO()
     stats.show_progress(stream=out)
-    s = '20 B O 20 B U 1 N '
-    buf = ' ' * (columns - len(s))
+    s = "20 B O 20 B U 1 N "
+    buf = " " * (columns - len(s))
     assert out.getvalue() == s + buf + "\r"
 
     out = StringIO()
-    stats.update(10 ** 3, unique=False)
-    stats.show_progress(item=Item(path='foo'), final=False, stream=out)
-    s = '1.02 kB O 20 B U 1 N foo'
-    buf = ' ' * (columns - len(s))
+    stats.update(10**3, unique=False)
+    stats.show_progress(item=Item(path="foo"), final=False, stream=out)
+    s = "1.02 kB O 20 B U 1 N foo"
+    buf = " " * (columns - len(s))
     assert out.getvalue() == s + buf + "\r"
     out = StringIO()
-    stats.show_progress(item=Item(path='foo'*40), final=False, stream=out)
-    s = '1.02 kB O 20 B U 1 N foofoofoofoofoofoofoofoofo...foofoofoofoofoofoofoofoofoofoo'
-    buf = ' ' * (columns - len(s))
+    stats.show_progress(item=Item(path="foo" * 40), final=False, stream=out)
+    s = "1.02 kB O 20 B U 1 N foofoofoofoofoofoofoofoofo...foofoofoofoofoofoofoofoofoofoo"
+    buf = " " * (columns - len(s))
     assert out.getvalue() == s + buf + "\r"
 
 
 def test_stats_format(stats):
-    assert str(stats) == """\
+    assert (
+        str(stats)
+        == """\
 Number of files: 1
 Original size: 20 B
 Deduplicated size: 20 B
 """
+    )
     s = f"{stats.osize_fmt}"
     assert s == "20 B"
     # kind of redundant, but id is variable so we can't match reliably
-    assert repr(stats) == f'<Statistics object at {id(stats):#x} (20, 20)>'
+    assert repr(stats) == f"<Statistics object at {id(stats):#x} (20, 20)>"
 
 
 def test_stats_progress_json(stats):
     stats.output_json = True
 
     out = StringIO()
-    stats.show_progress(item=Item(path='foo'), stream=out)
+    stats.show_progress(item=Item(path="foo"), stream=out)
     result = json.loads(out.getvalue())
-    assert result['type'] == 'archive_progress'
-    assert isinstance(result['time'], float)
-    assert result['finished'] is False
-    assert result['path'] == 'foo'
-    assert result['original_size'] == 20
-    assert result['nfiles'] == 1
+    assert result["type"] == "archive_progress"
+    assert isinstance(result["time"], float)
+    assert result["finished"] is False
+    assert result["path"] == "foo"
+    assert result["original_size"] == 20
+    assert result["nfiles"] == 1
 
     out = StringIO()
     stats.show_progress(stream=out, final=True)
     result = json.loads(out.getvalue())
-    assert result['type'] == 'archive_progress'
-    assert isinstance(result['time'], float)
-    assert result['finished'] is True  # see #6570
-    assert 'path' not in result
-    assert 'original_size' not in result
-    assert 'nfiles' not in result
+    assert result["type"] == "archive_progress"
+    assert isinstance(result["time"], float)
+    assert result["finished"] is True  # see #6570
+    assert "path" not in result
+    assert "original_size" not in result
+    assert "nfiles" not in result
 
 
 class MockCache:
-
     class MockRepo:
         def async_response(self, wait=True):
             pass
@@ -105,30 +107,24 @@ class MockCache:
 
 
 class ArchiveTimestampTestCase(BaseTestCase):
-
     def _test_timestamp_parsing(self, isoformat, expected):
         repository = Mock()
         key = PlaintextKey(repository)
         manifest = Manifest(repository, key)
-        a = Archive(repository, key, manifest, 'test', create=True)
+        a = Archive(repository, key, manifest, "test", create=True)
         a.metadata = ArchiveItem(time=isoformat)
         self.assert_equal(a.ts, expected)
 
     def test_with_microseconds(self):
-        self._test_timestamp_parsing(
-            '1970-01-01T00:00:01.000001',
-            datetime(1970, 1, 1, 0, 0, 1, 1, timezone.utc))
+        self._test_timestamp_parsing("1970-01-01T00:00:01.000001", datetime(1970, 1, 1, 0, 0, 1, 1, timezone.utc))
 
     def test_without_microseconds(self):
-        self._test_timestamp_parsing(
-            '1970-01-01T00:00:01',
-            datetime(1970, 1, 1, 0, 0, 1, 0, timezone.utc))
+        self._test_timestamp_parsing("1970-01-01T00:00:01", datetime(1970, 1, 1, 0, 0, 1, 0, timezone.utc))
 
 
 class ChunkBufferTestCase(BaseTestCase):
-
     def test(self):
-        data = [Item(path='p1'), Item(path='p2')]
+        data = [Item(path="p1"), Item(path="p2")]
         cache = MockCache()
         key = PlaintextKey(None)
         chunks = CacheChunkBuffer(cache, key, None)
@@ -144,7 +140,7 @@ class ChunkBufferTestCase(BaseTestCase):
 
     def test_partial(self):
         big = "0123456789abcdefghijklmnopqrstuvwxyz" * 25000
-        data = [Item(path='full', source=big), Item(path='partial', source=big)]
+        data = [Item(path="full", source=big), Item(path="partial", source=big)]
         cache = MockCache()
         key = PlaintextKey(None)
         chunks = CacheChunkBuffer(cache, key, None)
@@ -165,12 +161,11 @@ class ChunkBufferTestCase(BaseTestCase):
 
 
 class RobustUnpackerTestCase(BaseTestCase):
-
     def make_chunks(self, items):
-        return b''.join(msgpack.packb({'path': item}) for item in items)
+        return b"".join(msgpack.packb({"path": item}) for item in items)
 
     def _validator(self, value):
-        return isinstance(value, dict) and value.get('path') in ('foo', 'bar', 'boo', 'baz')
+        return isinstance(value, dict) and value.get("path") in ("foo", "bar", "boo", "baz")
 
     def process(self, input):
         unpacker = RobustUnpacker(validator=self._validator, item_keys=ITEM_KEYS)
@@ -185,14 +180,14 @@ class RobustUnpackerTestCase(BaseTestCase):
         return result
 
     def test_extra_garbage_no_sync(self):
-        chunks = [(False, [self.make_chunks(['foo', 'bar'])]),
-                  (False, [b'garbage'] + [self.make_chunks(['boo', 'baz'])])]
+        chunks = [
+            (False, [self.make_chunks(["foo", "bar"])]),
+            (False, [b"garbage"] + [self.make_chunks(["boo", "baz"])]),
+        ]
         result = self.process(chunks)
-        self.assert_equal(result, [
-            {'path': 'foo'}, {'path': 'bar'},
-            103, 97, 114, 98, 97, 103, 101,
-            {'path': 'boo'},
-            {'path': 'baz'}])
+        self.assert_equal(
+            result, [{"path": "foo"}, {"path": "bar"}, 103, 97, 114, 98, 97, 103, 101, {"path": "boo"}, {"path": "baz"}]
+        )
 
     def split(self, left, length):
         parts = []
@@ -202,22 +197,22 @@ class RobustUnpackerTestCase(BaseTestCase):
         return parts
 
     def test_correct_stream(self):
-        chunks = self.split(self.make_chunks(['foo', 'bar', 'boo', 'baz']), 2)
+        chunks = self.split(self.make_chunks(["foo", "bar", "boo", "baz"]), 2)
         input = [(False, chunks)]
         result = self.process(input)
-        self.assert_equal(result, [{'path': 'foo'}, {'path': 'bar'}, {'path': 'boo'}, {'path': 'baz'}])
+        self.assert_equal(result, [{"path": "foo"}, {"path": "bar"}, {"path": "boo"}, {"path": "baz"}])
 
     def test_missing_chunk(self):
-        chunks = self.split(self.make_chunks(['foo', 'bar', 'boo', 'baz']), 4)
+        chunks = self.split(self.make_chunks(["foo", "bar", "boo", "baz"]), 4)
         input = [(False, chunks[:3]), (True, chunks[4:])]
         result = self.process(input)
-        self.assert_equal(result, [{'path': 'foo'}, {'path': 'boo'}, {'path': 'baz'}])
+        self.assert_equal(result, [{"path": "foo"}, {"path": "boo"}, {"path": "baz"}])
 
     def test_corrupt_chunk(self):
-        chunks = self.split(self.make_chunks(['foo', 'bar', 'boo', 'baz']), 4)
-        input = [(False, chunks[:3]), (True, [b'gar', b'bage'] + chunks[3:])]
+        chunks = self.split(self.make_chunks(["foo", "bar", "boo", "baz"]), 4)
+        input = [(False, chunks[:3]), (True, [b"gar", b"bage"] + chunks[3:])]
         result = self.process(input)
-        self.assert_equal(result, [{'path': 'foo'}, {'path': 'boo'}, {'path': 'baz'}])
+        self.assert_equal(result, [{"path": "foo"}, {"path": "boo"}, {"path": "baz"}])
 
 
 @pytest.fixture
@@ -225,12 +220,17 @@ def item_keys_serialized():
     return [msgpack.packb(name) for name in ITEM_KEYS]
 
 
-@pytest.mark.parametrize('packed',
-    [b'', b'x', b'foobar', ] +
-    [msgpack.packb(o) for o in (
-        [None, 0, 0.0, False, '', {}, [], ()] +
-        [42, 23.42, True, b'foobar', {b'foo': b'bar'}, [b'foo', b'bar'], (b'foo', b'bar')]
-    )])
+@pytest.mark.parametrize(
+    "packed",
+    [b"", b"x", b"foobar"]
+    + [
+        msgpack.packb(o)
+        for o in (
+            [None, 0, 0.0, False, "", {}, [], ()]
+            + [42, 23.42, True, b"foobar", {b"foo": b"bar"}, [b"foo", b"bar"], (b"foo", b"bar")]
+        )
+    ],
+)
 def test_invalid_msgpacked_item(packed, item_keys_serialized):
     assert not valid_msgpacked_dict(packed, item_keys_serialized)
 
@@ -239,20 +239,25 @@ def test_invalid_msgpacked_item(packed, item_keys_serialized):
 IK = sorted(list(ITEM_KEYS))
 
 
-@pytest.mark.parametrize('packed',
-    [msgpack.packb(o) for o in [
-        {'path': b'/a/b/c'},  # small (different msgpack mapping type!)
-        OrderedDict((k, b'') for k in IK),  # as big (key count) as it gets
-        OrderedDict((k, b'x' * 1000) for k in IK),  # as big (key count and volume) as it gets
-    ]])
+@pytest.mark.parametrize(
+    "packed",
+    [
+        msgpack.packb(o)
+        for o in [
+            {"path": b"/a/b/c"},  # small (different msgpack mapping type!)
+            OrderedDict((k, b"") for k in IK),  # as big (key count) as it gets
+            OrderedDict((k, b"x" * 1000) for k in IK),  # as big (key count and volume) as it gets
+        ]
+    ],
+)
 def test_valid_msgpacked_items(packed, item_keys_serialized):
     assert valid_msgpacked_dict(packed, item_keys_serialized)
 
 
 def test_key_length_msgpacked_items():
-    key = 'x' * 32  # 31 bytes is the limit for fixstr msgpack type
-    data = {key: b''}
-    item_keys_serialized = [msgpack.packb(key), ]
+    key = "x" * 32  # 31 bytes is the limit for fixstr msgpack type
+    data = {key: b""}
+    item_keys_serialized = [msgpack.packb(key)]
     assert valid_msgpacked_dict(msgpack.packb(data), item_keys_serialized)
 
 
@@ -277,7 +282,7 @@ def test_backup_io_iter():
 
     normal_iterator = Iterator(StopIteration)
     for _ in backup_io_iter(normal_iterator):
-        assert False, 'StopIteration handled incorrectly'
+        assert False, "StopIteration handled incorrectly"
 
 
 def test_get_item_uid_gid():
@@ -288,7 +293,7 @@ def test_get_item_uid_gid():
     user0, group0 = uid2user(0), gid2group(0)
 
     # this is intentionally a "strange" item, with not matching ids/names.
-    item = Item(path='filename', uid=1, gid=2, user=user0, group=group0)
+    item = Item(path="filename", uid=1, gid=2, user=user0, group=group0)
 
     uid, gid = get_item_uid_gid(item, numeric=False)
     # these are found via a name-to-id lookup
@@ -306,7 +311,7 @@ def test_get_item_uid_gid():
     assert gid == 4
 
     # item metadata broken, has negative ids.
-    item = Item(path='filename', uid=-1, gid=-2, user=user0, group=group0)
+    item = Item(path="filename", uid=-1, gid=-2, user=user0, group=group0)
 
     uid, gid = get_item_uid_gid(item, numeric=True)
     # use the uid/gid defaults (which both default to 0).
@@ -319,7 +324,7 @@ def test_get_item_uid_gid():
     assert gid == 6
 
     # item metadata broken, has negative ids and non-existing user/group names.
-    item = Item(path='filename', uid=-3, gid=-4, user='udoesnotexist', group='gdoesnotexist')
+    item = Item(path="filename", uid=-3, gid=-4, user="udoesnotexist", group="gdoesnotexist")
 
     uid, gid = get_item_uid_gid(item, numeric=False)
     # use the uid/gid defaults (which both default to 0).
@@ -332,7 +337,7 @@ def test_get_item_uid_gid():
     assert gid == 8
 
     # item metadata has valid uid/gid, but non-existing user/group names.
-    item = Item(path='filename', uid=9, gid=10, user='udoesnotexist', group='gdoesnotexist')
+    item = Item(path="filename", uid=9, gid=10, user="udoesnotexist", group="gdoesnotexist")
 
     uid, gid = get_item_uid_gid(item, numeric=False)
     # because user/group name does not exist here, use valid numeric ids from item metadata.
diff --git a/src/borg/testsuite/archiver.py b/src/borg/testsuite/archiver.py
index 4a29440d4..63bb8beca 100644
--- a/src/borg/testsuite/archiver.py
+++ b/src/borg/testsuite/archiver.py
@@ -53,32 +53,38 @@ from ..remote import RemoteRepository, PathNotAllowed
 from ..repository import Repository
 from . import has_lchflags, llfuse
 from . import BaseTestCase, changedir, environment_variable, no_selinux
-from . import are_symlinks_supported, are_hardlinks_supported, are_fifos_supported, is_utime_fully_supported, is_birthtime_fully_supported
+from . import (
+    are_symlinks_supported,
+    are_hardlinks_supported,
+    are_fifos_supported,
+    is_utime_fully_supported,
+    is_birthtime_fully_supported,
+)
 from .platform import fakeroot_detected, is_darwin
 from . import key
 
-RK_ENCRYPTION = '--encryption=repokey-aes-ocb'
-KF_ENCRYPTION = '--encryption=keyfile-chacha20-poly1305'
+RK_ENCRYPTION = "--encryption=repokey-aes-ocb"
+KF_ENCRYPTION = "--encryption=keyfile-chacha20-poly1305"
 
-src_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), '..'))
+src_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), ".."))
 
 
-def exec_cmd(*args, archiver=None, fork=False, exe=None, input=b'', binary_output=False, **kw):
+def exec_cmd(*args, archiver=None, fork=False, exe=None, input=b"", binary_output=False, **kw):
     if fork:
         try:
             if exe is None:
-                borg = (sys.executable, '-m', 'borg.archiver')
+                borg = (sys.executable, "-m", "borg.archiver")
             elif isinstance(exe, str):
-                borg = (exe, )
+                borg = (exe,)
             elif not isinstance(exe, tuple):
-                raise ValueError('exe must be None, a tuple or a str')
+                raise ValueError("exe must be None, a tuple or a str")
             output = subprocess.check_output(borg + args, stderr=subprocess.STDOUT, input=input)
             ret = 0
         except subprocess.CalledProcessError as e:
             output = e.output
             ret = e.returncode
         except SystemExit as e:  # possibly raised by argparse
-            output = ''
+            output = ""
             ret = e.code
         if binary_output:
             return ret, output
@@ -91,7 +97,7 @@ def exec_cmd(*args, archiver=None, fork=False, exe=None, input=b'', binary_outpu
             sys.stdin.buffer = BytesIO(input)
             output = BytesIO()
             # Always use utf-8 here, to simply .decode() below
-            output_text = sys.stdout = sys.stderr = io.TextIOWrapper(output, encoding='utf-8')
+            output_text = sys.stdout = sys.stderr = io.TextIOWrapper(output, encoding="utf-8")
             if archiver is None:
                 archiver = Archiver()
             archiver.prerun_checks = lambda *args: None
@@ -113,50 +119,51 @@ def exec_cmd(*args, archiver=None, fork=False, exe=None, input=b'', binary_outpu
 
 
 def have_gnutar():
-    if not shutil.which('tar'):
+    if not shutil.which("tar"):
         return False
-    popen = subprocess.Popen(['tar', '--version'], stdout=subprocess.PIPE)
+    popen = subprocess.Popen(["tar", "--version"], stdout=subprocess.PIPE)
     stdout, stderr = popen.communicate()
-    return b'GNU tar' in stdout
+    return b"GNU tar" in stdout
 
 
 # check if the binary "borg.exe" is available (for local testing a symlink to virtualenv/bin/borg should do)
 try:
-    exec_cmd('help', exe='borg.exe', fork=True)
-    BORG_EXES = ['python', 'binary', ]
+    exec_cmd("help", exe="borg.exe", fork=True)
+    BORG_EXES = ["python", "binary"]
 except FileNotFoundError:
-    BORG_EXES = ['python', ]
+    BORG_EXES = ["python"]
 
 
 @pytest.fixture(params=BORG_EXES)
 def cmd(request):
-    if request.param == 'python':
+    if request.param == "python":
         exe = None
-    elif request.param == 'binary':
-        exe = 'borg.exe'
+    elif request.param == "binary":
+        exe = "borg.exe"
     else:
         raise ValueError("param must be 'python' or 'binary'")
 
     def exec_fn(*args, **kw):
         return exec_cmd(*args, exe=exe, fork=True, **kw)
+
     return exec_fn
 
 
 def test_return_codes(cmd, tmpdir):
-    repo = tmpdir.mkdir('repo')
-    input = tmpdir.mkdir('input')
-    output = tmpdir.mkdir('output')
-    input.join('test_file').write('content')
-    rc, out = cmd('--repo=%s' % str(repo), 'rcreate', '--encryption=none')
+    repo = tmpdir.mkdir("repo")
+    input = tmpdir.mkdir("input")
+    output = tmpdir.mkdir("output")
+    input.join("test_file").write("content")
+    rc, out = cmd("--repo=%s" % str(repo), "rcreate", "--encryption=none")
     assert rc == EXIT_SUCCESS
-    rc, out = cmd('--repo=%s' % repo, 'create', 'archive', str(input))
+    rc, out = cmd("--repo=%s" % repo, "create", "archive", str(input))
     assert rc == EXIT_SUCCESS
     with changedir(str(output)):
-        rc, out = cmd('--repo=%s' % repo, 'extract', 'archive')
+        rc, out = cmd("--repo=%s" % repo, "extract", "archive")
         assert rc == EXIT_SUCCESS
-    rc, out = cmd('--repo=%s' % repo, 'extract', 'archive', 'does/not/match')
+    rc, out = cmd("--repo=%s" % repo, "extract", "archive", "does/not/match")
     assert rc == EXIT_WARNING  # pattern did not match
-    rc, out = cmd('--repo=%s' % repo, 'create', 'archive', str(input))
+    rc, out = cmd("--repo=%s" % repo, "create", "archive", str(input))
     assert rc == EXIT_ERROR  # duplicate archive name
 
 
@@ -174,7 +181,7 @@ sudo mount /tmp/borg-disk /tmp/borg-mount
 
 if the directory does not exist, the test will be skipped.
 """
-DF_MOUNT = '/tmp/borg-mount'
+DF_MOUNT = "/tmp/borg-mount"
 
 
 @pytest.mark.skipif(not os.path.exists(DF_MOUNT), reason="needs a 16MB fs mounted on %s" % DF_MOUNT)
@@ -188,24 +195,24 @@ def test_disk_full(cmd):
                 size = random.randint(1, size)
         for i in range(count):
             fn = os.path.join(dir, "file%03d" % i)
-            with open(fn, 'wb') as f:
+            with open(fn, "wb") as f:
                 data = os.urandom(size)
                 f.write(data)
 
-    with environment_variable(BORG_CHECK_I_KNOW_WHAT_I_AM_DOING='YES'):
+    with environment_variable(BORG_CHECK_I_KNOW_WHAT_I_AM_DOING="YES"):
         mount = DF_MOUNT
         assert os.path.exists(mount)
-        repo = os.path.join(mount, 'repo')
-        input = os.path.join(mount, 'input')
-        reserve = os.path.join(mount, 'reserve')
+        repo = os.path.join(mount, "repo")
+        input = os.path.join(mount, "input")
+        reserve = os.path.join(mount, "reserve")
         for j in range(100):
             shutil.rmtree(repo, ignore_errors=True)
             shutil.rmtree(input, ignore_errors=True)
             # keep some space and some inodes in reserve that we can free up later:
             make_files(reserve, 80, 100000, rnd=False)
-            rc, out = cmd(f'--repo={repo}', 'rcreate')
+            rc, out = cmd(f"--repo={repo}", "rcreate")
             if rc != EXIT_SUCCESS:
-                print('rcreate', rc, out)
+                print("rcreate", rc, out)
             assert rc == EXIT_SUCCESS
             try:
                 success, i = True, 0
@@ -219,58 +226,58 @@ def test_disk_full(cmd):
                             break
                         raise
                     try:
-                        rc, out = cmd('--repo=%s' % repo, 'create', 'test%03d' % i, input)
+                        rc, out = cmd("--repo=%s" % repo, "create", "test%03d" % i, input)
                         success = rc == EXIT_SUCCESS
                         if not success:
-                            print('create', rc, out)
+                            print("create", rc, out)
                     finally:
                         # make sure repo is not locked
-                        shutil.rmtree(os.path.join(repo, 'lock.exclusive'), ignore_errors=True)
-                        os.remove(os.path.join(repo, 'lock.roster'))
+                        shutil.rmtree(os.path.join(repo, "lock.exclusive"), ignore_errors=True)
+                        os.remove(os.path.join(repo, "lock.roster"))
             finally:
                 # now some error happened, likely we are out of disk space.
                 # free some space so we can expect borg to be able to work normally:
                 shutil.rmtree(reserve, ignore_errors=True)
-            rc, out = cmd(f'--repo={repo}', 'rlist')
+            rc, out = cmd(f"--repo={repo}", "rlist")
             if rc != EXIT_SUCCESS:
-                print('rlist', rc, out)
-            rc, out = cmd(f'--repo={repo}', 'check', '--repair')
+                print("rlist", rc, out)
+            rc, out = cmd(f"--repo={repo}", "check", "--repair")
             if rc != EXIT_SUCCESS:
-                print('check', rc, out)
+                print("check", rc, out)
             assert rc == EXIT_SUCCESS
 
 
 class ArchiverTestCaseBase(BaseTestCase):
     EXE = None  # python source based
     FORK_DEFAULT = False
-    prefix = ''
+    prefix = ""
 
     def setUp(self):
-        os.environ['BORG_CHECK_I_KNOW_WHAT_I_AM_DOING'] = 'YES'
-        os.environ['BORG_DELETE_I_KNOW_WHAT_I_AM_DOING'] = 'YES'
-        os.environ['BORG_PASSPHRASE'] = 'waytooeasyonlyfortests'
-        os.environ['BORG_SELFTEST'] = 'disabled'
+        os.environ["BORG_CHECK_I_KNOW_WHAT_I_AM_DOING"] = "YES"
+        os.environ["BORG_DELETE_I_KNOW_WHAT_I_AM_DOING"] = "YES"
+        os.environ["BORG_PASSPHRASE"] = "waytooeasyonlyfortests"
+        os.environ["BORG_SELFTEST"] = "disabled"
         self.archiver = not self.FORK_DEFAULT and Archiver() or None
         self.tmpdir = tempfile.mkdtemp()
-        self.repository_path = os.path.join(self.tmpdir, 'repository')
+        self.repository_path = os.path.join(self.tmpdir, "repository")
         self.repository_location = self.prefix + self.repository_path
-        self.input_path = os.path.join(self.tmpdir, 'input')
-        self.output_path = os.path.join(self.tmpdir, 'output')
-        self.keys_path = os.path.join(self.tmpdir, 'keys')
-        self.cache_path = os.path.join(self.tmpdir, 'cache')
-        self.exclude_file_path = os.path.join(self.tmpdir, 'excludes')
-        self.patterns_file_path = os.path.join(self.tmpdir, 'patterns')
-        os.environ['BORG_KEYS_DIR'] = self.keys_path
-        os.environ['BORG_CACHE_DIR'] = self.cache_path
+        self.input_path = os.path.join(self.tmpdir, "input")
+        self.output_path = os.path.join(self.tmpdir, "output")
+        self.keys_path = os.path.join(self.tmpdir, "keys")
+        self.cache_path = os.path.join(self.tmpdir, "cache")
+        self.exclude_file_path = os.path.join(self.tmpdir, "excludes")
+        self.patterns_file_path = os.path.join(self.tmpdir, "patterns")
+        os.environ["BORG_KEYS_DIR"] = self.keys_path
+        os.environ["BORG_CACHE_DIR"] = self.cache_path
         os.mkdir(self.input_path)
         os.chmod(self.input_path, 0o777)  # avoid troubles with fakeroot / FUSE
         os.mkdir(self.output_path)
         os.mkdir(self.keys_path)
         os.mkdir(self.cache_path)
-        with open(self.exclude_file_path, 'wb') as fd:
-            fd.write(b'input/file2\n# A comment line, then a blank line\n\n')
-        with open(self.patterns_file_path, 'wb') as fd:
-            fd.write(b'+input/file_important\n- input/file*\n# A comment line, then a blank line\n\n')
+        with open(self.exclude_file_path, "wb") as fd:
+            fd.write(b"input/file2\n# A comment line, then a blank line\n\n")
+        with open(self.patterns_file_path, "wb") as fd:
+            fd.write(b"+input/file_important\n- input/file*\n# A comment line, then a blank line\n\n")
         self._old_wd = os.getcwd()
         os.chdir(self.tmpdir)
 
@@ -281,9 +288,9 @@ class ArchiverTestCaseBase(BaseTestCase):
         setup_logging()
 
     def cmd(self, *args, **kw):
-        exit_code = kw.pop('exit_code', 0)
-        fork = kw.pop('fork', None)
-        binary_output = kw.get('binary_output', False)
+        exit_code = kw.pop("exit_code", 0)
+        fork = kw.pop("fork", None)
+        binary_output = kw.get("binary_output", False)
         if fork is None:
             fork = self.FORK_DEFAULT
         ret, output = exec_cmd(*args, fork=fork, exe=self.EXE, archiver=self.archiver, **kw)
@@ -293,13 +300,12 @@ class ArchiverTestCaseBase(BaseTestCase):
         # if tests are run with the pure-python msgpack, there will be warnings about
         # this in the output, which would make a lot of tests fail.
         pp_msg = PURE_PYTHON_MSGPACK_WARNING.encode() if binary_output else PURE_PYTHON_MSGPACK_WARNING
-        empty = b'' if binary_output else ''
-        output = empty.join(line for line in output.splitlines(keepends=True)
-                            if pp_msg not in line)
+        empty = b"" if binary_output else ""
+        output = empty.join(line for line in output.splitlines(keepends=True) if pp_msg not in line)
         return output
 
     def create_src_archive(self, name):
-        self.cmd(f'--repo={self.repository_location}', 'create', '--compression=lz4', name, src_dir)
+        self.cmd(f"--repo={self.repository_location}", "create", "--compression=lz4", name, src_dir)
 
     def open_archive(self, name):
         repository = Repository(self.repository_path, exclusive=True)
@@ -312,42 +318,40 @@ class ArchiverTestCaseBase(BaseTestCase):
         return Repository(self.repository_path, exclusive=True)
 
     def create_regular_file(self, name, size=0, contents=None):
-        assert not (size != 0 and contents and len(contents) != size), 'size and contents do not match'
+        assert not (size != 0 and contents and len(contents) != size), "size and contents do not match"
         filename = os.path.join(self.input_path, name)
         if not os.path.exists(os.path.dirname(filename)):
             os.makedirs(os.path.dirname(filename))
-        with open(filename, 'wb') as fd:
+        with open(filename, "wb") as fd:
             if contents is None:
-                contents = b'X' * size
+                contents = b"X" * size
             fd.write(contents)
 
     def create_test_files(self, create_hardlinks=True):
-        """Create a minimal test case including all supported file types
-        """
+        """Create a minimal test case including all supported file types"""
         # File
-        self.create_regular_file('file1', size=1024 * 80)
-        self.create_regular_file('flagfile', size=1024)
+        self.create_regular_file("file1", size=1024 * 80)
+        self.create_regular_file("flagfile", size=1024)
         # Directory
-        self.create_regular_file('dir2/file2', size=1024 * 80)
+        self.create_regular_file("dir2/file2", size=1024 * 80)
         # File mode
-        os.chmod('input/file1', 0o4755)
+        os.chmod("input/file1", 0o4755)
         # Hard link
         if are_hardlinks_supported() and create_hardlinks:
-            os.link(os.path.join(self.input_path, 'file1'),
-                    os.path.join(self.input_path, 'hardlink'))
+            os.link(os.path.join(self.input_path, "file1"), os.path.join(self.input_path, "hardlink"))
         # Symlink
         if are_symlinks_supported():
-            os.symlink('somewhere', os.path.join(self.input_path, 'link1'))
-        self.create_regular_file('fusexattr', size=1)
+            os.symlink("somewhere", os.path.join(self.input_path, "link1"))
+        self.create_regular_file("fusexattr", size=1)
         if not xattr.XATTR_FAKEROOT and xattr.is_enabled(self.input_path):
-            fn = os.fsencode(os.path.join(self.input_path, 'fusexattr'))
+            fn = os.fsencode(os.path.join(self.input_path, "fusexattr"))
             # ironically, due to the way how fakeroot works, comparing FUSE file xattrs to orig file xattrs
             # will FAIL if fakeroot supports xattrs, thus we only set the xattr if XATTR_FAKEROOT is False.
             # This is because fakeroot with xattr-support does not propagate xattrs of the underlying file
             # into "fakeroot space". Because the xattrs exposed by borgfs are these of an underlying file
             # (from fakeroots point of view) they are invisible to the test process inside the fakeroot.
-            xattr.setxattr(fn, b'user.foo', b'bar')
-            xattr.setxattr(fn, b'user.empty', b'')
+            xattr.setxattr(fn, b"user.foo", b"bar")
+            xattr.setxattr(fn, b"user.empty", b"")
             # XXX this always fails for me
             # ubuntu 14.04, on a TMP dir filesystem with user_xattr, using fakeroot
             # same for newer ubuntu and centos.
@@ -356,18 +360,18 @@ class ArchiverTestCaseBase(BaseTestCase):
             # xattr.setxattr(os.path.join(self.input_path, 'link1'), b'user.foo_symlink', b'bar_symlink', follow_symlinks=False)
         # FIFO node
         if are_fifos_supported():
-            os.mkfifo(os.path.join(self.input_path, 'fifo1'))
+            os.mkfifo(os.path.join(self.input_path, "fifo1"))
         if has_lchflags:
-            platform.set_flags(os.path.join(self.input_path, 'flagfile'), stat.UF_NODUMP)
+            platform.set_flags(os.path.join(self.input_path, "flagfile"), stat.UF_NODUMP)
         try:
             # Block device
-            os.mknod('input/bdev', 0o600 | stat.S_IFBLK, os.makedev(10, 20))
+            os.mknod("input/bdev", 0o600 | stat.S_IFBLK, os.makedev(10, 20))
             # Char device
-            os.mknod('input/cdev', 0o600 | stat.S_IFCHR, os.makedev(30, 40))
+            os.mknod("input/cdev", 0o600 | stat.S_IFCHR, os.makedev(30, 40))
             # File mode
-            os.chmod('input/dir2', 0o555)  # if we take away write perms, we need root to remove contents
+            os.chmod("input/dir2", 0o555)  # if we take away write perms, we need root to remove contents
             # File owner
-            os.chown('input/file1', 100, 200)  # raises OSError invalid argument on cygwin
+            os.chown("input/file1", 100, 200)  # raises OSError invalid argument on cygwin
             have_root = True  # we have (fake)root
         except PermissionError:
             have_root = False
@@ -377,12 +381,12 @@ class ArchiverTestCaseBase(BaseTestCase):
                 raise
             have_root = False
         time.sleep(1)  # "empty" must have newer timestamp than other files
-        self.create_regular_file('empty', size=0)
+        self.create_regular_file("empty", size=0)
         return have_root
 
 
 class ArchiverTestCase(ArchiverTestCaseBase):
-    requires_hardlinks = pytest.mark.skipif(not are_hardlinks_supported(), reason='hardlinks not supported')
+    requires_hardlinks = pytest.mark.skipif(not are_hardlinks_supported(), reason="hardlinks not supported")
 
     def get_security_dir(self):
         repository_id = bin_to_hex(self._extract_repository_id(self.repository_path))
@@ -391,61 +395,64 @@ class ArchiverTestCase(ArchiverTestCaseBase):
     def test_basic_functionality(self):
         have_root = self.create_test_files()
         # fork required to test show-rc output
-        output = self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION, '--show-version', '--show-rc', fork=True)
-        self.assert_in('borgbackup version', output)
-        self.assert_in('terminating with success status, rc 0', output)
-        self.cmd(f'--repo={self.repository_location}', 'create', '--exclude-nodump', 'test', 'input')
-        output = self.cmd(f'--repo={self.repository_location}', 'create', '--exclude-nodump', '--stats', 'test.2', 'input')
-        self.assert_in('Archive name: test.2', output)
-        with changedir('output'):
-            self.cmd(f'--repo={self.repository_location}', 'extract', 'test')
-        list_output = self.cmd(f'--repo={self.repository_location}', 'rlist', '--short')
-        self.assert_in('test', list_output)
-        self.assert_in('test.2', list_output)
+        output = self.cmd(
+            f"--repo={self.repository_location}", "rcreate", RK_ENCRYPTION, "--show-version", "--show-rc", fork=True
+        )
+        self.assert_in("borgbackup version", output)
+        self.assert_in("terminating with success status, rc 0", output)
+        self.cmd(f"--repo={self.repository_location}", "create", "--exclude-nodump", "test", "input")
+        output = self.cmd(
+            f"--repo={self.repository_location}", "create", "--exclude-nodump", "--stats", "test.2", "input"
+        )
+        self.assert_in("Archive name: test.2", output)
+        with changedir("output"):
+            self.cmd(f"--repo={self.repository_location}", "extract", "test")
+        list_output = self.cmd(f"--repo={self.repository_location}", "rlist", "--short")
+        self.assert_in("test", list_output)
+        self.assert_in("test.2", list_output)
         expected = [
-            'input',
-            'input/bdev',
-            'input/cdev',
-            'input/dir2',
-            'input/dir2/file2',
-            'input/empty',
-            'input/file1',
-            'input/flagfile',
+            "input",
+            "input/bdev",
+            "input/cdev",
+            "input/dir2",
+            "input/dir2/file2",
+            "input/empty",
+            "input/file1",
+            "input/flagfile",
         ]
         if are_fifos_supported():
-            expected.append('input/fifo1')
+            expected.append("input/fifo1")
         if are_symlinks_supported():
-            expected.append('input/link1')
+            expected.append("input/link1")
         if are_hardlinks_supported():
-            expected.append('input/hardlink')
+            expected.append("input/hardlink")
         if not have_root:
             # we could not create these device files without (fake)root
-            expected.remove('input/bdev')
-            expected.remove('input/cdev')
+            expected.remove("input/bdev")
+            expected.remove("input/cdev")
         if has_lchflags:
             # remove the file we did not backup, so input and output become equal
-            expected.remove('input/flagfile')  # this file is UF_NODUMP
-            os.remove(os.path.join('input', 'flagfile'))
-        list_output = self.cmd(f'--repo={self.repository_location}', 'list', 'test', '--short')
+            expected.remove("input/flagfile")  # this file is UF_NODUMP
+            os.remove(os.path.join("input", "flagfile"))
+        list_output = self.cmd(f"--repo={self.repository_location}", "list", "test", "--short")
         for name in expected:
             self.assert_in(name, list_output)
-        self.assert_dirs_equal('input', 'output/input')
-        info_output = self.cmd(f'--repo={self.repository_location}', 'info', '-a', 'test')
+        self.assert_dirs_equal("input", "output/input")
+        info_output = self.cmd(f"--repo={self.repository_location}", "info", "-a", "test")
         item_count = 5 if has_lchflags else 6  # one file is UF_NODUMP
-        self.assert_in('Number of files: %d' % item_count, info_output)
+        self.assert_in("Number of files: %d" % item_count, info_output)
         shutil.rmtree(self.cache_path)
-        info_output2 = self.cmd(f'--repo={self.repository_location}', 'info', '-a', 'test')
+        info_output2 = self.cmd(f"--repo={self.repository_location}", "info", "-a", "test")
 
         def filter(output):
             # filter for interesting "info" output, ignore cache rebuilding related stuff
-            prefixes = ['Name:', 'Fingerprint:', 'Number of files:', 'This archive:',
-                        'All archives:', 'Chunk index:', ]
+            prefixes = ["Name:", "Fingerprint:", "Number of files:", "This archive:", "All archives:", "Chunk index:"]
             result = []
             for line in output.splitlines():
                 for prefix in prefixes:
                     if line.startswith(prefix):
                         result.append(line)
-            return '\n'.join(result)
+            return "\n".join(result)
 
         # the interesting parts of info_output2 and info_output should be same
         self.assert_equal(filter(info_output), filter(info_output2))
@@ -453,82 +460,84 @@ class ArchiverTestCase(ArchiverTestCaseBase):
     @requires_hardlinks
     def test_create_duplicate_root(self):
         # setup for #5603
-        path_a = os.path.join(self.input_path, 'a')
-        path_b = os.path.join(self.input_path, 'b')
+        path_a = os.path.join(self.input_path, "a")
+        path_b = os.path.join(self.input_path, "b")
         os.mkdir(path_a)
         os.mkdir(path_b)
-        hl_a = os.path.join(path_a, 'hardlink')
-        hl_b = os.path.join(path_b, 'hardlink')
-        self.create_regular_file(hl_a, contents=b'123456')
+        hl_a = os.path.join(path_a, "hardlink")
+        hl_b = os.path.join(path_b, "hardlink")
+        self.create_regular_file(hl_a, contents=b"123456")
         os.link(hl_a, hl_b)
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=none')
-        self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input', 'input')  # give input twice!
+        self.cmd(f"--repo={self.repository_location}", "rcreate", "--encryption=none")
+        self.cmd(f"--repo={self.repository_location}", "create", "test", "input", "input")  # give input twice!
         # test if created archive has 'input' contents twice:
-        archive_list = self.cmd(f'--repo={self.repository_location}', 'list', 'test', '--json-lines')
-        paths = [json.loads(line)['path'] for line in archive_list.split('\n') if line]
+        archive_list = self.cmd(f"--repo={self.repository_location}", "list", "test", "--json-lines")
+        paths = [json.loads(line)["path"] for line in archive_list.split("\n") if line]
         # we have all fs items exactly once!
-        assert sorted(paths) == ['input', 'input/a', 'input/a/hardlink', 'input/b', 'input/b/hardlink']
+        assert sorted(paths) == ["input", "input/a", "input/a/hardlink", "input/b", "input/b/hardlink"]
 
     def test_init_parent_dirs(self):
-        parent_path = os.path.join(self.tmpdir, 'parent1', 'parent2')
-        repository_path = os.path.join(parent_path, 'repository')
+        parent_path = os.path.join(self.tmpdir, "parent1", "parent2")
+        repository_path = os.path.join(parent_path, "repository")
         repository_location = self.prefix + repository_path
         with pytest.raises(Repository.ParentPathDoesNotExist):
             # normal borg init does NOT create missing parent dirs
-            self.cmd(f'--repo={repository_location}', 'rcreate', '--encryption=none')
+            self.cmd(f"--repo={repository_location}", "rcreate", "--encryption=none")
         # but if told so, it does:
-        self.cmd(f'--repo={repository_location}', 'rcreate', '--encryption=none', '--make-parent-dirs')
+        self.cmd(f"--repo={repository_location}", "rcreate", "--encryption=none", "--make-parent-dirs")
         assert os.path.exists(parent_path)
 
     def test_unix_socket(self):
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
+        self.cmd(f"--repo={self.repository_location}", "rcreate", RK_ENCRYPTION)
         try:
             sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
-            sock.bind(os.path.join(self.input_path, 'unix-socket'))
+            sock.bind(os.path.join(self.input_path, "unix-socket"))
         except PermissionError as err:
             if err.errno == errno.EPERM:
-                pytest.skip('unix sockets disabled or not supported')
+                pytest.skip("unix sockets disabled or not supported")
             elif err.errno == errno.EACCES:
-                pytest.skip('permission denied to create unix sockets')
-        self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
+                pytest.skip("permission denied to create unix sockets")
+        self.cmd(f"--repo={self.repository_location}", "create", "test", "input")
         sock.close()
-        with changedir('output'):
-            self.cmd(f'--repo={self.repository_location}', 'extract', 'test')
-            assert not os.path.exists('input/unix-socket')
+        with changedir("output"):
+            self.cmd(f"--repo={self.repository_location}", "extract", "test")
+            assert not os.path.exists("input/unix-socket")
 
-    @pytest.mark.skipif(not are_symlinks_supported(), reason='symlinks not supported')
+    @pytest.mark.skipif(not are_symlinks_supported(), reason="symlinks not supported")
     def test_symlink_extract(self):
         self.create_test_files()
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
-        self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
-        with changedir('output'):
-            self.cmd(f'--repo={self.repository_location}', 'extract', 'test')
-            assert os.readlink('input/link1') == 'somewhere'
+        self.cmd(f"--repo={self.repository_location}", "rcreate", RK_ENCRYPTION)
+        self.cmd(f"--repo={self.repository_location}", "create", "test", "input")
+        with changedir("output"):
+            self.cmd(f"--repo={self.repository_location}", "extract", "test")
+            assert os.readlink("input/link1") == "somewhere"
 
-    @pytest.mark.skipif(not are_symlinks_supported() or not are_hardlinks_supported() or is_darwin,
-                        reason='symlinks or hardlinks or hardlinked symlinks not supported')
+    @pytest.mark.skipif(
+        not are_symlinks_supported() or not are_hardlinks_supported() or is_darwin,
+        reason="symlinks or hardlinks or hardlinked symlinks not supported",
+    )
     def test_hardlinked_symlinks_extract(self):
-        self.create_regular_file('target', size=1024)
-        with changedir('input'):
-            os.symlink('target', 'symlink1')
-            os.link('symlink1', 'symlink2', follow_symlinks=False)
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
-        self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
-        with changedir('output'):
-            output = self.cmd(f'--repo={self.repository_location}', 'extract', 'test')
+        self.create_regular_file("target", size=1024)
+        with changedir("input"):
+            os.symlink("target", "symlink1")
+            os.link("symlink1", "symlink2", follow_symlinks=False)
+        self.cmd(f"--repo={self.repository_location}", "rcreate", RK_ENCRYPTION)
+        self.cmd(f"--repo={self.repository_location}", "create", "test", "input")
+        with changedir("output"):
+            output = self.cmd(f"--repo={self.repository_location}", "extract", "test")
             print(output)
-            with changedir('input'):
-                assert os.path.exists('target')
-                assert os.readlink('symlink1') == 'target'
-                assert os.readlink('symlink2') == 'target'
-                st1 = os.stat('symlink1', follow_symlinks=False)
-                st2 = os.stat('symlink2', follow_symlinks=False)
+            with changedir("input"):
+                assert os.path.exists("target")
+                assert os.readlink("symlink1") == "target"
+                assert os.readlink("symlink2") == "target"
+                st1 = os.stat("symlink1", follow_symlinks=False)
+                st2 = os.stat("symlink2", follow_symlinks=False)
                 assert st1.st_nlink == 2
                 assert st2.st_nlink == 2
                 assert st1.st_ino == st2.st_ino
                 assert st1.st_size == st2.st_size
 
-    @pytest.mark.skipif(not is_utime_fully_supported(), reason='cannot properly setup and execute test without utime')
+    @pytest.mark.skipif(not is_utime_fully_supported(), reason="cannot properly setup and execute test without utime")
     def test_atime(self):
         def has_noatime(some_file):
             atime_before = os.stat(some_file).st_atime_ns
@@ -544,14 +553,14 @@ class ArchiverTestCase(ArchiverTestCaseBase):
 
         self.create_test_files()
         atime, mtime = 123456780, 234567890
-        have_noatime = has_noatime('input/file1')
-        os.utime('input/file1', (atime, mtime))
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
-        self.cmd(f'--repo={self.repository_location}', 'create', '--atime', 'test', 'input')
-        with changedir('output'):
-            self.cmd(f'--repo={self.repository_location}', 'extract', 'test')
-        sti = os.stat('input/file1')
-        sto = os.stat('output/input/file1')
+        have_noatime = has_noatime("input/file1")
+        os.utime("input/file1", (atime, mtime))
+        self.cmd(f"--repo={self.repository_location}", "rcreate", RK_ENCRYPTION)
+        self.cmd(f"--repo={self.repository_location}", "create", "--atime", "test", "input")
+        with changedir("output"):
+            self.cmd(f"--repo={self.repository_location}", "extract", "test")
+        sti = os.stat("input/file1")
+        sto = os.stat("output/input/file1")
         assert sti.st_mtime_ns == sto.st_mtime_ns == mtime * 1e9
         if have_noatime:
             assert sti.st_atime_ns == sto.st_atime_ns == atime * 1e9
@@ -559,35 +568,39 @@ class ArchiverTestCase(ArchiverTestCaseBase):
             # it touched the input file's atime while backing it up
             assert sto.st_atime_ns == atime * 1e9
 
-    @pytest.mark.skipif(not is_utime_fully_supported(), reason='cannot properly setup and execute test without utime')
-    @pytest.mark.skipif(not is_birthtime_fully_supported(), reason='cannot properly setup and execute test without birthtime')
+    @pytest.mark.skipif(not is_utime_fully_supported(), reason="cannot properly setup and execute test without utime")
+    @pytest.mark.skipif(
+        not is_birthtime_fully_supported(), reason="cannot properly setup and execute test without birthtime"
+    )
     def test_birthtime(self):
         self.create_test_files()
         birthtime, mtime, atime = 946598400, 946684800, 946771200
-        os.utime('input/file1', (atime, birthtime))
-        os.utime('input/file1', (atime, mtime))
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
-        self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
-        with changedir('output'):
-            self.cmd(f'--repo={self.repository_location}', 'extract', 'test')
-        sti = os.stat('input/file1')
-        sto = os.stat('output/input/file1')
+        os.utime("input/file1", (atime, birthtime))
+        os.utime("input/file1", (atime, mtime))
+        self.cmd(f"--repo={self.repository_location}", "rcreate", RK_ENCRYPTION)
+        self.cmd(f"--repo={self.repository_location}", "create", "test", "input")
+        with changedir("output"):
+            self.cmd(f"--repo={self.repository_location}", "extract", "test")
+        sti = os.stat("input/file1")
+        sto = os.stat("output/input/file1")
         assert int(sti.st_birthtime * 1e9) == int(sto.st_birthtime * 1e9) == birthtime * 1e9
         assert sti.st_mtime_ns == sto.st_mtime_ns == mtime * 1e9
 
-    @pytest.mark.skipif(not is_utime_fully_supported(), reason='cannot properly setup and execute test without utime')
-    @pytest.mark.skipif(not is_birthtime_fully_supported(), reason='cannot properly setup and execute test without birthtime')
+    @pytest.mark.skipif(not is_utime_fully_supported(), reason="cannot properly setup and execute test without utime")
+    @pytest.mark.skipif(
+        not is_birthtime_fully_supported(), reason="cannot properly setup and execute test without birthtime"
+    )
     def test_nobirthtime(self):
         self.create_test_files()
         birthtime, mtime, atime = 946598400, 946684800, 946771200
-        os.utime('input/file1', (atime, birthtime))
-        os.utime('input/file1', (atime, mtime))
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
-        self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input', '--nobirthtime')
-        with changedir('output'):
-            self.cmd(f'--repo={self.repository_location}', 'extract', 'test')
-        sti = os.stat('input/file1')
-        sto = os.stat('output/input/file1')
+        os.utime("input/file1", (atime, birthtime))
+        os.utime("input/file1", (atime, mtime))
+        self.cmd(f"--repo={self.repository_location}", "rcreate", RK_ENCRYPTION)
+        self.cmd(f"--repo={self.repository_location}", "create", "test", "input", "--nobirthtime")
+        with changedir("output"):
+            self.cmd(f"--repo={self.repository_location}", "extract", "test")
+        sti = os.stat("input/file1")
+        sto = os.stat("output/input/file1")
         assert int(sti.st_birthtime * 1e9) == birthtime * 1e9
         assert int(sto.st_birthtime * 1e9) == mtime * 1e9
         assert sti.st_mtime_ns == sto.st_mtime_ns == mtime * 1e9
@@ -598,9 +611,9 @@ class ArchiverTestCase(ArchiverTestCaseBase):
 
     def _set_repository_id(self, path, id):
         config = ConfigParser(interpolation=None)
-        config.read(os.path.join(path, 'config'))
-        config.set('repository', 'id', bin_to_hex(id))
-        with open(os.path.join(path, 'config'), 'w') as fd:
+        config.read(os.path.join(path, "config"))
+        config.set("repository", "id", bin_to_hex(id))
+        with open(os.path.join(path, "config"), "w") as fd:
             config.write(fd)
         with Repository(self.repository_path) as repository:
             return repository.id
@@ -610,10 +623,10 @@ class ArchiverTestCase(ArchiverTestCaseBase):
             st = os.stat(fn)
             assert st.st_size == total_size
             sparse = True
-            if sparse and hasattr(st, 'st_blocks') and st.st_blocks * 512 >= st.st_size:
+            if sparse and hasattr(st, "st_blocks") and st.st_blocks * 512 >= st.st_size:
                 sparse = False
             if sparse and has_seek_hole:
-                with open(fn, 'rb') as fd:
+                with open(fn, "rb") as fd:
                     # only check if the first hole is as expected, because the 2nd hole check
                     # is problematic on xfs due to its "dynamic speculative EOF preallocation
                     try:
@@ -626,11 +639,11 @@ class ArchiverTestCase(ArchiverTestCaseBase):
                         sparse = False
             return sparse
 
-        filename = os.path.join(self.input_path, 'sparse')
-        content = b'foobar'
+        filename = os.path.join(self.input_path, "sparse")
+        content = b"foobar"
         hole_size = 5 * (1 << CHUNK_MAX_EXP)  # 5 full chunker buffers
         total_size = hole_size + len(content) + hole_size
-        with open(filename, 'wb') as fd:
+        with open(filename, "wb") as fd:
             # create a file that has a hole at the beginning and end (if the
             # OS and filesystem supports sparse files)
             fd.seek(hole_size, 1)
@@ -643,1140 +656,1269 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         if sparse_support:
             # we could create a sparse input file, so creating a backup of it and
             # extracting it again (as sparse) should also work:
-            self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
-            self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
+            self.cmd(f"--repo={self.repository_location}", "rcreate", RK_ENCRYPTION)
+            self.cmd(f"--repo={self.repository_location}", "create", "test", "input")
             with changedir(self.output_path):
-                self.cmd(f'--repo={self.repository_location}', 'extract', 'test', '--sparse')
-            self.assert_dirs_equal('input', 'output/input')
-            filename = os.path.join(self.output_path, 'input', 'sparse')
-            with open(filename, 'rb') as fd:
+                self.cmd(f"--repo={self.repository_location}", "extract", "test", "--sparse")
+            self.assert_dirs_equal("input", "output/input")
+            filename = os.path.join(self.output_path, "input", "sparse")
+            with open(filename, "rb") as fd:
                 # check if file contents are as expected
-                self.assert_equal(fd.read(hole_size), b'\0' * hole_size)
+                self.assert_equal(fd.read(hole_size), b"\0" * hole_size)
                 self.assert_equal(fd.read(len(content)), content)
-                self.assert_equal(fd.read(hole_size), b'\0' * hole_size)
+                self.assert_equal(fd.read(hole_size), b"\0" * hole_size)
             assert is_sparse(filename, total_size, hole_size)
 
     def test_unusual_filenames(self):
-        filenames = ['normal', 'with some blanks', '(with_parens)', ]
+        filenames = ["normal", "with some blanks", "(with_parens)"]
         for filename in filenames:
             filename = os.path.join(self.input_path, filename)
-            with open(filename, 'wb'):
+            with open(filename, "wb"):
                 pass
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
-        self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
+        self.cmd(f"--repo={self.repository_location}", "rcreate", RK_ENCRYPTION)
+        self.cmd(f"--repo={self.repository_location}", "create", "test", "input")
         for filename in filenames:
-            with changedir('output'):
-                self.cmd(f'--repo={self.repository_location}', 'extract', 'test', os.path.join('input', filename))
-            assert os.path.exists(os.path.join('output', 'input', filename))
+            with changedir("output"):
+                self.cmd(f"--repo={self.repository_location}", "extract", "test", os.path.join("input", filename))
+            assert os.path.exists(os.path.join("output", "input", filename))
 
     def test_repository_swap_detection(self):
         self.create_test_files()
-        os.environ['BORG_PASSPHRASE'] = 'passphrase'
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
+        os.environ["BORG_PASSPHRASE"] = "passphrase"
+        self.cmd(f"--repo={self.repository_location}", "rcreate", RK_ENCRYPTION)
         repository_id = self._extract_repository_id(self.repository_path)
-        self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
+        self.cmd(f"--repo={self.repository_location}", "create", "test", "input")
         shutil.rmtree(self.repository_path)
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=none')
+        self.cmd(f"--repo={self.repository_location}", "rcreate", "--encryption=none")
         self._set_repository_id(self.repository_path, repository_id)
         self.assert_equal(repository_id, self._extract_repository_id(self.repository_path))
         if self.FORK_DEFAULT:
-            self.cmd(f'--repo={self.repository_location}', 'create', 'test.2', 'input', exit_code=EXIT_ERROR)
+            self.cmd(f"--repo={self.repository_location}", "create", "test.2", "input", exit_code=EXIT_ERROR)
         else:
             with pytest.raises(Cache.EncryptionMethodMismatch):
-                self.cmd(f'--repo={self.repository_location}', 'create', 'test.2', 'input')
+                self.cmd(f"--repo={self.repository_location}", "create", "test.2", "input")
 
     def test_repository_swap_detection2(self):
         self.create_test_files()
-        self.cmd(f'--repo={self.repository_location}_unencrypted', 'rcreate', '--encryption=none')
-        os.environ['BORG_PASSPHRASE'] = 'passphrase'
-        self.cmd(f'--repo={self.repository_location}_encrypted', 'rcreate', RK_ENCRYPTION)
-        self.cmd(f'--repo={self.repository_location}_encrypted', 'create', 'test', 'input')
-        shutil.rmtree(self.repository_path + '_encrypted')
-        os.rename(self.repository_path + '_unencrypted', self.repository_path + '_encrypted')
+        self.cmd(f"--repo={self.repository_location}_unencrypted", "rcreate", "--encryption=none")
+        os.environ["BORG_PASSPHRASE"] = "passphrase"
+        self.cmd(f"--repo={self.repository_location}_encrypted", "rcreate", RK_ENCRYPTION)
+        self.cmd(f"--repo={self.repository_location}_encrypted", "create", "test", "input")
+        shutil.rmtree(self.repository_path + "_encrypted")
+        os.rename(self.repository_path + "_unencrypted", self.repository_path + "_encrypted")
         if self.FORK_DEFAULT:
-            self.cmd(f'--repo={self.repository_location}_encrypted', 'create', 'test.2', 'input', exit_code=EXIT_ERROR)
+            self.cmd(f"--repo={self.repository_location}_encrypted", "create", "test.2", "input", exit_code=EXIT_ERROR)
         else:
             with pytest.raises(Cache.RepositoryAccessAborted):
-                self.cmd(f'--repo={self.repository_location}_encrypted', 'create', 'test.2', 'input')
+                self.cmd(f"--repo={self.repository_location}_encrypted", "create", "test.2", "input")
 
     def test_repository_swap_detection_no_cache(self):
         self.create_test_files()
-        os.environ['BORG_PASSPHRASE'] = 'passphrase'
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
+        os.environ["BORG_PASSPHRASE"] = "passphrase"
+        self.cmd(f"--repo={self.repository_location}", "rcreate", RK_ENCRYPTION)
         repository_id = self._extract_repository_id(self.repository_path)
-        self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
+        self.cmd(f"--repo={self.repository_location}", "create", "test", "input")
         shutil.rmtree(self.repository_path)
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=none')
+        self.cmd(f"--repo={self.repository_location}", "rcreate", "--encryption=none")
         self._set_repository_id(self.repository_path, repository_id)
         self.assert_equal(repository_id, self._extract_repository_id(self.repository_path))
-        self.cmd(f'--repo={self.repository_location}', 'rdelete', '--cache-only')
+        self.cmd(f"--repo={self.repository_location}", "rdelete", "--cache-only")
         if self.FORK_DEFAULT:
-            self.cmd(f'--repo={self.repository_location}', 'create', 'test.2', 'input', exit_code=EXIT_ERROR)
+            self.cmd(f"--repo={self.repository_location}", "create", "test.2", "input", exit_code=EXIT_ERROR)
         else:
             with pytest.raises(Cache.EncryptionMethodMismatch):
-                self.cmd(f'--repo={self.repository_location}', 'create', 'test.2', 'input')
+                self.cmd(f"--repo={self.repository_location}", "create", "test.2", "input")
 
     def test_repository_swap_detection2_no_cache(self):
         self.create_test_files()
-        self.cmd(f'--repo={self.repository_location}_unencrypted', 'rcreate', '--encryption=none')
-        os.environ['BORG_PASSPHRASE'] = 'passphrase'
-        self.cmd(f'--repo={self.repository_location}_encrypted', 'rcreate', RK_ENCRYPTION)
-        self.cmd(f'--repo={self.repository_location}_encrypted', 'create', 'test', 'input')
-        self.cmd(f'--repo={self.repository_location}_unencrypted', 'rdelete', '--cache-only')
-        self.cmd(f'--repo={self.repository_location}_encrypted', 'rdelete', '--cache-only')
-        shutil.rmtree(self.repository_path + '_encrypted')
-        os.rename(self.repository_path + '_unencrypted', self.repository_path + '_encrypted')
+        self.cmd(f"--repo={self.repository_location}_unencrypted", "rcreate", "--encryption=none")
+        os.environ["BORG_PASSPHRASE"] = "passphrase"
+        self.cmd(f"--repo={self.repository_location}_encrypted", "rcreate", RK_ENCRYPTION)
+        self.cmd(f"--repo={self.repository_location}_encrypted", "create", "test", "input")
+        self.cmd(f"--repo={self.repository_location}_unencrypted", "rdelete", "--cache-only")
+        self.cmd(f"--repo={self.repository_location}_encrypted", "rdelete", "--cache-only")
+        shutil.rmtree(self.repository_path + "_encrypted")
+        os.rename(self.repository_path + "_unencrypted", self.repository_path + "_encrypted")
         if self.FORK_DEFAULT:
-            self.cmd(f'--repo={self.repository_location}_encrypted', 'create', 'test.2', 'input', exit_code=EXIT_ERROR)
+            self.cmd(f"--repo={self.repository_location}_encrypted", "create", "test.2", "input", exit_code=EXIT_ERROR)
         else:
             with pytest.raises(Cache.RepositoryAccessAborted):
-                self.cmd(f'--repo={self.repository_location}_encrypted', 'create', 'test.2', 'input')
+                self.cmd(f"--repo={self.repository_location}_encrypted", "create", "test.2", "input")
 
     def test_repository_swap_detection_repokey_blank_passphrase(self):
         # Check that a repokey repo with a blank passphrase is considered like a plaintext repo.
         self.create_test_files()
         # User initializes her repository with her passphrase
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
-        self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
+        self.cmd(f"--repo={self.repository_location}", "rcreate", RK_ENCRYPTION)
+        self.cmd(f"--repo={self.repository_location}", "create", "test", "input")
         # Attacker replaces it with her own repository, which is encrypted but has no passphrase set
         shutil.rmtree(self.repository_path)
-        with environment_variable(BORG_PASSPHRASE=''):
-            self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
+        with environment_variable(BORG_PASSPHRASE=""):
+            self.cmd(f"--repo={self.repository_location}", "rcreate", RK_ENCRYPTION)
             # Delete cache & security database, AKA switch to user perspective
-            self.cmd(f'--repo={self.repository_location}', 'rdelete', '--cache-only')
+            self.cmd(f"--repo={self.repository_location}", "rdelete", "--cache-only")
             shutil.rmtree(self.get_security_dir())
         with environment_variable(BORG_PASSPHRASE=None):
             # This is the part were the user would be tricked, e.g. she assumes that BORG_PASSPHRASE
             # is set, while it isn't. Previously this raised no warning,
             # since the repository is, technically, encrypted.
             if self.FORK_DEFAULT:
-                self.cmd(f'--repo={self.repository_location}', 'create', 'test.2', 'input', exit_code=EXIT_ERROR)
+                self.cmd(f"--repo={self.repository_location}", "create", "test.2", "input", exit_code=EXIT_ERROR)
             else:
                 with pytest.raises(Cache.CacheInitAbortedError):
-                    self.cmd(f'--repo={self.repository_location}', 'create', 'test.2', 'input')
+                    self.cmd(f"--repo={self.repository_location}", "create", "test.2", "input")
 
     def test_repository_move(self):
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
+        self.cmd(f"--repo={self.repository_location}", "rcreate", RK_ENCRYPTION)
         security_dir = self.get_security_dir()
-        os.rename(self.repository_path, self.repository_path + '_new')
-        with environment_variable(BORG_RELOCATED_REPO_ACCESS_IS_OK='yes'):
-            self.cmd(f'--repo={self.repository_location}_new', 'rinfo')
-        with open(os.path.join(security_dir, 'location')) as fd:
+        os.rename(self.repository_path, self.repository_path + "_new")
+        with environment_variable(BORG_RELOCATED_REPO_ACCESS_IS_OK="yes"):
+            self.cmd(f"--repo={self.repository_location}_new", "rinfo")
+        with open(os.path.join(security_dir, "location")) as fd:
             location = fd.read()
-            assert location == Location(self.repository_location + '_new').canonical_path()
+            assert location == Location(self.repository_location + "_new").canonical_path()
         # Needs no confirmation anymore
-        self.cmd(f'--repo={self.repository_location}_new', 'rinfo')
+        self.cmd(f"--repo={self.repository_location}_new", "rinfo")
         shutil.rmtree(self.cache_path)
-        self.cmd(f'--repo={self.repository_location}_new', 'rinfo')
+        self.cmd(f"--repo={self.repository_location}_new", "rinfo")
         shutil.rmtree(security_dir)
-        self.cmd(f'--repo={self.repository_location}_new', 'rinfo')
-        for file in ('location', 'key-type', 'manifest-timestamp'):
+        self.cmd(f"--repo={self.repository_location}_new", "rinfo")
+        for file in ("location", "key-type", "manifest-timestamp"):
             assert os.path.exists(os.path.join(security_dir, file))
 
     def test_security_dir_compat(self):
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
-        with open(os.path.join(self.get_security_dir(), 'location'), 'w') as fd:
-            fd.write('something outdated')
+        self.cmd(f"--repo={self.repository_location}", "rcreate", RK_ENCRYPTION)
+        with open(os.path.join(self.get_security_dir(), "location"), "w") as fd:
+            fd.write("something outdated")
         # This is fine, because the cache still has the correct information. security_dir and cache can disagree
         # if older versions are used to confirm a renamed repository.
-        self.cmd(f'--repo={self.repository_location}', 'rinfo')
+        self.cmd(f"--repo={self.repository_location}", "rinfo")
 
     def test_unknown_unencrypted(self):
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=none')
+        self.cmd(f"--repo={self.repository_location}", "rcreate", "--encryption=none")
         # Ok: repository is known
-        self.cmd(f'--repo={self.repository_location}', 'rinfo')
+        self.cmd(f"--repo={self.repository_location}", "rinfo")
 
         # Ok: repository is still known (through security_dir)
         shutil.rmtree(self.cache_path)
-        self.cmd(f'--repo={self.repository_location}', 'rinfo')
+        self.cmd(f"--repo={self.repository_location}", "rinfo")
 
         # Needs confirmation: cache and security dir both gone (eg. another host or rm -rf ~)
         shutil.rmtree(self.cache_path)
         shutil.rmtree(self.get_security_dir())
         if self.FORK_DEFAULT:
-            self.cmd(f'--repo={self.repository_location}', 'rinfo', exit_code=EXIT_ERROR)
+            self.cmd(f"--repo={self.repository_location}", "rinfo", exit_code=EXIT_ERROR)
         else:
             with pytest.raises(Cache.CacheInitAbortedError):
-                self.cmd(f'--repo={self.repository_location}', 'rinfo')
-        with environment_variable(BORG_UNKNOWN_UNENCRYPTED_REPO_ACCESS_IS_OK='yes'):
-            self.cmd(f'--repo={self.repository_location}', 'rinfo')
+                self.cmd(f"--repo={self.repository_location}", "rinfo")
+        with environment_variable(BORG_UNKNOWN_UNENCRYPTED_REPO_ACCESS_IS_OK="yes"):
+            self.cmd(f"--repo={self.repository_location}", "rinfo")
 
     def test_strip_components(self):
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
-        self.create_regular_file('dir/file')
-        self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
-        with changedir('output'):
-            self.cmd(f'--repo={self.repository_location}', 'extract', 'test', '--strip-components', '3')
-            assert not os.path.exists('file')
-            with self.assert_creates_file('file'):
-                self.cmd(f'--repo={self.repository_location}', 'extract', 'test', '--strip-components', '2')
-            with self.assert_creates_file('dir/file'):
-                self.cmd(f'--repo={self.repository_location}', 'extract', 'test', '--strip-components', '1')
-            with self.assert_creates_file('input/dir/file'):
-                self.cmd(f'--repo={self.repository_location}', 'extract', 'test', '--strip-components', '0')
+        self.cmd(f"--repo={self.repository_location}", "rcreate", RK_ENCRYPTION)
+        self.create_regular_file("dir/file")
+        self.cmd(f"--repo={self.repository_location}", "create", "test", "input")
+        with changedir("output"):
+            self.cmd(f"--repo={self.repository_location}", "extract", "test", "--strip-components", "3")
+            assert not os.path.exists("file")
+            with self.assert_creates_file("file"):
+                self.cmd(f"--repo={self.repository_location}", "extract", "test", "--strip-components", "2")
+            with self.assert_creates_file("dir/file"):
+                self.cmd(f"--repo={self.repository_location}", "extract", "test", "--strip-components", "1")
+            with self.assert_creates_file("input/dir/file"):
+                self.cmd(f"--repo={self.repository_location}", "extract", "test", "--strip-components", "0")
 
     def _extract_hardlinks_setup(self):
-        os.mkdir(os.path.join(self.input_path, 'dir1'))
-        os.mkdir(os.path.join(self.input_path, 'dir1/subdir'))
+        os.mkdir(os.path.join(self.input_path, "dir1"))
+        os.mkdir(os.path.join(self.input_path, "dir1/subdir"))
 
-        self.create_regular_file('source', contents=b'123456')
-        os.link(os.path.join(self.input_path, 'source'),
-                os.path.join(self.input_path, 'abba'))
-        os.link(os.path.join(self.input_path, 'source'),
-                os.path.join(self.input_path, 'dir1/hardlink'))
-        os.link(os.path.join(self.input_path, 'source'),
-                os.path.join(self.input_path, 'dir1/subdir/hardlink'))
+        self.create_regular_file("source", contents=b"123456")
+        os.link(os.path.join(self.input_path, "source"), os.path.join(self.input_path, "abba"))
+        os.link(os.path.join(self.input_path, "source"), os.path.join(self.input_path, "dir1/hardlink"))
+        os.link(os.path.join(self.input_path, "source"), os.path.join(self.input_path, "dir1/subdir/hardlink"))
 
-        self.create_regular_file('dir1/source2')
-        os.link(os.path.join(self.input_path, 'dir1/source2'),
-                os.path.join(self.input_path, 'dir1/aaaa'))
+        self.create_regular_file("dir1/source2")
+        os.link(os.path.join(self.input_path, "dir1/source2"), os.path.join(self.input_path, "dir1/aaaa"))
 
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
-        self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
+        self.cmd(f"--repo={self.repository_location}", "rcreate", RK_ENCRYPTION)
+        self.cmd(f"--repo={self.repository_location}", "create", "test", "input")
 
     @requires_hardlinks
-    @unittest.skipUnless(llfuse, 'llfuse not installed')
+    @unittest.skipUnless(llfuse, "llfuse not installed")
     def test_fuse_mount_hardlinks(self):
         self._extract_hardlinks_setup()
-        mountpoint = os.path.join(self.tmpdir, 'mountpoint')
+        mountpoint = os.path.join(self.tmpdir, "mountpoint")
         # we need to get rid of permissions checking because fakeroot causes issues with it.
         # On all platforms, borg defaults to "default_permissions" and we need to get rid of it via "ignore_permissions".
         # On macOS (darwin), we additionally need "defer_permissions" to switch off the checks in osxfuse.
-        if sys.platform == 'darwin':
-            ignore_perms = ['-o', 'ignore_permissions,defer_permissions']
+        if sys.platform == "darwin":
+            ignore_perms = ["-o", "ignore_permissions,defer_permissions"]
         else:
-            ignore_perms = ['-o', 'ignore_permissions']
-        with self.fuse_mount(self.repository_location, mountpoint, '-a', 'test', '--strip-components=2', *ignore_perms), \
-             changedir(os.path.join(mountpoint, 'test')):
-            assert os.stat('hardlink').st_nlink == 2
-            assert os.stat('subdir/hardlink').st_nlink == 2
-            assert open('subdir/hardlink', 'rb').read() == b'123456'
-            assert os.stat('aaaa').st_nlink == 2
-            assert os.stat('source2').st_nlink == 2
-        with self.fuse_mount(self.repository_location, mountpoint, 'input/dir1', '-a', 'test', *ignore_perms), \
-             changedir(os.path.join(mountpoint, 'test')):
-            assert os.stat('input/dir1/hardlink').st_nlink == 2
-            assert os.stat('input/dir1/subdir/hardlink').st_nlink == 2
-            assert open('input/dir1/subdir/hardlink', 'rb').read() == b'123456'
-            assert os.stat('input/dir1/aaaa').st_nlink == 2
-            assert os.stat('input/dir1/source2').st_nlink == 2
-        with self.fuse_mount(self.repository_location, mountpoint, '-a', 'test', *ignore_perms), \
-             changedir(os.path.join(mountpoint, 'test')):
-            assert os.stat('input/source').st_nlink == 4
-            assert os.stat('input/abba').st_nlink == 4
-            assert os.stat('input/dir1/hardlink').st_nlink == 4
-            assert os.stat('input/dir1/subdir/hardlink').st_nlink == 4
-            assert open('input/dir1/subdir/hardlink', 'rb').read() == b'123456'
+            ignore_perms = ["-o", "ignore_permissions"]
+        with self.fuse_mount(
+            self.repository_location, mountpoint, "-a", "test", "--strip-components=2", *ignore_perms
+        ), changedir(os.path.join(mountpoint, "test")):
+            assert os.stat("hardlink").st_nlink == 2
+            assert os.stat("subdir/hardlink").st_nlink == 2
+            assert open("subdir/hardlink", "rb").read() == b"123456"
+            assert os.stat("aaaa").st_nlink == 2
+            assert os.stat("source2").st_nlink == 2
+        with self.fuse_mount(
+            self.repository_location, mountpoint, "input/dir1", "-a", "test", *ignore_perms
+        ), changedir(os.path.join(mountpoint, "test")):
+            assert os.stat("input/dir1/hardlink").st_nlink == 2
+            assert os.stat("input/dir1/subdir/hardlink").st_nlink == 2
+            assert open("input/dir1/subdir/hardlink", "rb").read() == b"123456"
+            assert os.stat("input/dir1/aaaa").st_nlink == 2
+            assert os.stat("input/dir1/source2").st_nlink == 2
+        with self.fuse_mount(self.repository_location, mountpoint, "-a", "test", *ignore_perms), changedir(
+            os.path.join(mountpoint, "test")
+        ):
+            assert os.stat("input/source").st_nlink == 4
+            assert os.stat("input/abba").st_nlink == 4
+            assert os.stat("input/dir1/hardlink").st_nlink == 4
+            assert os.stat("input/dir1/subdir/hardlink").st_nlink == 4
+            assert open("input/dir1/subdir/hardlink", "rb").read() == b"123456"
 
     @requires_hardlinks
     def test_extract_hardlinks1(self):
         self._extract_hardlinks_setup()
-        with changedir('output'):
-            self.cmd(f'--repo={self.repository_location}', 'extract', 'test')
-            assert os.stat('input/source').st_nlink == 4
-            assert os.stat('input/abba').st_nlink == 4
-            assert os.stat('input/dir1/hardlink').st_nlink == 4
-            assert os.stat('input/dir1/subdir/hardlink').st_nlink == 4
-            assert open('input/dir1/subdir/hardlink', 'rb').read() == b'123456'
+        with changedir("output"):
+            self.cmd(f"--repo={self.repository_location}", "extract", "test")
+            assert os.stat("input/source").st_nlink == 4
+            assert os.stat("input/abba").st_nlink == 4
+            assert os.stat("input/dir1/hardlink").st_nlink == 4
+            assert os.stat("input/dir1/subdir/hardlink").st_nlink == 4
+            assert open("input/dir1/subdir/hardlink", "rb").read() == b"123456"
 
     @requires_hardlinks
     def test_extract_hardlinks2(self):
         self._extract_hardlinks_setup()
-        with changedir('output'):
-            self.cmd(f'--repo={self.repository_location}', 'extract', 'test', '--strip-components', '2')
-            assert os.stat('hardlink').st_nlink == 2
-            assert os.stat('subdir/hardlink').st_nlink == 2
-            assert open('subdir/hardlink', 'rb').read() == b'123456'
-            assert os.stat('aaaa').st_nlink == 2
-            assert os.stat('source2').st_nlink == 2
-        with changedir('output'):
-            self.cmd(f'--repo={self.repository_location}', 'extract', 'test', 'input/dir1')
-            assert os.stat('input/dir1/hardlink').st_nlink == 2
-            assert os.stat('input/dir1/subdir/hardlink').st_nlink == 2
-            assert open('input/dir1/subdir/hardlink', 'rb').read() == b'123456'
-            assert os.stat('input/dir1/aaaa').st_nlink == 2
-            assert os.stat('input/dir1/source2').st_nlink == 2
+        with changedir("output"):
+            self.cmd(f"--repo={self.repository_location}", "extract", "test", "--strip-components", "2")
+            assert os.stat("hardlink").st_nlink == 2
+            assert os.stat("subdir/hardlink").st_nlink == 2
+            assert open("subdir/hardlink", "rb").read() == b"123456"
+            assert os.stat("aaaa").st_nlink == 2
+            assert os.stat("source2").st_nlink == 2
+        with changedir("output"):
+            self.cmd(f"--repo={self.repository_location}", "extract", "test", "input/dir1")
+            assert os.stat("input/dir1/hardlink").st_nlink == 2
+            assert os.stat("input/dir1/subdir/hardlink").st_nlink == 2
+            assert open("input/dir1/subdir/hardlink", "rb").read() == b"123456"
+            assert os.stat("input/dir1/aaaa").st_nlink == 2
+            assert os.stat("input/dir1/source2").st_nlink == 2
 
     @requires_hardlinks
     def test_extract_hardlinks_twice(self):
         # setup for #5603
-        path_a = os.path.join(self.input_path, 'a')
-        path_b = os.path.join(self.input_path, 'b')
+        path_a = os.path.join(self.input_path, "a")
+        path_b = os.path.join(self.input_path, "b")
         os.mkdir(path_a)
         os.mkdir(path_b)
-        hl_a = os.path.join(path_a, 'hardlink')
-        hl_b = os.path.join(path_b, 'hardlink')
-        self.create_regular_file(hl_a, contents=b'123456')
+        hl_a = os.path.join(path_a, "hardlink")
+        hl_b = os.path.join(path_b, "hardlink")
+        self.create_regular_file(hl_a, contents=b"123456")
         os.link(hl_a, hl_b)
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=none')
-        self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input', 'input')  # give input twice!
+        self.cmd(f"--repo={self.repository_location}", "rcreate", "--encryption=none")
+        self.cmd(f"--repo={self.repository_location}", "create", "test", "input", "input")  # give input twice!
         # now test extraction
-        with changedir('output'):
-            self.cmd(f'--repo={self.repository_location}', 'extract', 'test')
+        with changedir("output"):
+            self.cmd(f"--repo={self.repository_location}", "extract", "test")
             # if issue #5603 happens, extraction gives rc == 1 (triggering AssertionError) and warnings like:
             # input/a/hardlink: link: [Errno 2] No such file or directory: 'input/a/hardlink' -> 'input/a/hardlink'
             # input/b/hardlink: link: [Errno 2] No such file or directory: 'input/a/hardlink' -> 'input/b/hardlink'
             # otherwise, when fixed, the hardlinks should be there and have a link count of 2
-            assert os.stat('input/a/hardlink').st_nlink == 2
-            assert os.stat('input/b/hardlink').st_nlink == 2
+            assert os.stat("input/a/hardlink").st_nlink == 2
+            assert os.stat("input/b/hardlink").st_nlink == 2
 
     def test_extract_include_exclude(self):
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
-        self.create_regular_file('file1', size=1024 * 80)
-        self.create_regular_file('file2', size=1024 * 80)
-        self.create_regular_file('file3', size=1024 * 80)
-        self.create_regular_file('file4', size=1024 * 80)
-        self.cmd(f'--repo={self.repository_location}', 'create', '--exclude=input/file4', 'test', 'input')
-        with changedir('output'):
-            self.cmd(f'--repo={self.repository_location}', 'extract', 'test', 'input/file1', )
-        self.assert_equal(sorted(os.listdir('output/input')), ['file1'])
-        with changedir('output'):
-            self.cmd(f'--repo={self.repository_location}', 'extract', 'test', '--exclude=input/file2')
-        self.assert_equal(sorted(os.listdir('output/input')), ['file1', 'file3'])
-        with changedir('output'):
-            self.cmd(f'--repo={self.repository_location}', 'extract', 'test', '--exclude-from=' + self.exclude_file_path)
-        self.assert_equal(sorted(os.listdir('output/input')), ['file1', 'file3'])
+        self.cmd(f"--repo={self.repository_location}", "rcreate", RK_ENCRYPTION)
+        self.create_regular_file("file1", size=1024 * 80)
+        self.create_regular_file("file2", size=1024 * 80)
+        self.create_regular_file("file3", size=1024 * 80)
+        self.create_regular_file("file4", size=1024 * 80)
+        self.cmd(f"--repo={self.repository_location}", "create", "--exclude=input/file4", "test", "input")
+        with changedir("output"):
+            self.cmd(f"--repo={self.repository_location}", "extract", "test", "input/file1")
+        self.assert_equal(sorted(os.listdir("output/input")), ["file1"])
+        with changedir("output"):
+            self.cmd(f"--repo={self.repository_location}", "extract", "test", "--exclude=input/file2")
+        self.assert_equal(sorted(os.listdir("output/input")), ["file1", "file3"])
+        with changedir("output"):
+            self.cmd(
+                f"--repo={self.repository_location}", "extract", "test", "--exclude-from=" + self.exclude_file_path
+            )
+        self.assert_equal(sorted(os.listdir("output/input")), ["file1", "file3"])
 
     def test_extract_include_exclude_regex(self):
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
-        self.create_regular_file('file1', size=1024 * 80)
-        self.create_regular_file('file2', size=1024 * 80)
-        self.create_regular_file('file3', size=1024 * 80)
-        self.create_regular_file('file4', size=1024 * 80)
-        self.create_regular_file('file333', size=1024 * 80)
-
-        # Create with regular expression exclusion for file4
-        self.cmd(f'--repo={self.repository_location}', 'create', '--exclude=re:input/file4$', 'test', 'input')
-        with changedir('output'):
-            self.cmd(f'--repo={self.repository_location}', 'extract', 'test')
-        self.assert_equal(sorted(os.listdir('output/input')), ['file1', 'file2', 'file3', 'file333'])
-        shutil.rmtree('output/input')
-
-        # Extract with regular expression exclusion
-        with changedir('output'):
-            self.cmd(f'--repo={self.repository_location}', 'extract', 'test', '--exclude=re:file3+')
-        self.assert_equal(sorted(os.listdir('output/input')), ['file1', 'file2'])
-        shutil.rmtree('output/input')
-
-        # Combine --exclude with fnmatch and regular expression
-        with changedir('output'):
-            self.cmd(f'--repo={self.repository_location}', 'extract', 'test', '--exclude=input/file2', '--exclude=re:file[01]')
-        self.assert_equal(sorted(os.listdir('output/input')), ['file3', 'file333'])
-        shutil.rmtree('output/input')
-
-        # Combine --exclude-from and regular expression exclusion
-        with changedir('output'):
-            self.cmd(f'--repo={self.repository_location}', 'extract', 'test', '--exclude-from=' + self.exclude_file_path,
-                     '--exclude=re:file1', '--exclude=re:file(\\d)\\1\\1$')
-        self.assert_equal(sorted(os.listdir('output/input')), ['file3'])
-
-    def test_extract_include_exclude_regex_from_file(self):
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
-        self.create_regular_file('file1', size=1024 * 80)
-        self.create_regular_file('file2', size=1024 * 80)
-        self.create_regular_file('file3', size=1024 * 80)
-        self.create_regular_file('file4', size=1024 * 80)
-        self.create_regular_file('file333', size=1024 * 80)
-        self.create_regular_file('aa:something', size=1024 * 80)
-
-        # Create while excluding using mixed pattern styles
-        with open(self.exclude_file_path, 'wb') as fd:
-            fd.write(b're:input/file4$\n')
-            fd.write(b'fm:*aa:*thing\n')
-
-        self.cmd(f'--repo={self.repository_location}', 'create', '--exclude-from=' + self.exclude_file_path, 'test', 'input')
-        with changedir('output'):
-            self.cmd(f'--repo={self.repository_location}', 'extract', 'test')
-        self.assert_equal(sorted(os.listdir('output/input')), ['file1', 'file2', 'file3', 'file333'])
-        shutil.rmtree('output/input')
-
-        # Exclude using regular expression
-        with open(self.exclude_file_path, 'wb') as fd:
-            fd.write(b're:file3+\n')
-
-        with changedir('output'):
-            self.cmd(f'--repo={self.repository_location}', 'extract', 'test', '--exclude-from=' + self.exclude_file_path)
-        self.assert_equal(sorted(os.listdir('output/input')), ['file1', 'file2'])
-        shutil.rmtree('output/input')
-
-        # Mixed exclude pattern styles
-        with open(self.exclude_file_path, 'wb') as fd:
-            fd.write(b're:file(\\d)\\1\\1$\n')
-            fd.write(b'fm:nothingwillmatchthis\n')
-            fd.write(b'*/file1\n')
-            fd.write(b're:file2$\n')
-
-        with changedir('output'):
-            self.cmd(f'--repo={self.repository_location}', 'extract', 'test', '--exclude-from=' + self.exclude_file_path)
-        self.assert_equal(sorted(os.listdir('output/input')), ['file3'])
-
-    def test_extract_with_pattern(self):
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
+        self.cmd(f"--repo={self.repository_location}", "rcreate", RK_ENCRYPTION)
         self.create_regular_file("file1", size=1024 * 80)
         self.create_regular_file("file2", size=1024 * 80)
         self.create_regular_file("file3", size=1024 * 80)
         self.create_regular_file("file4", size=1024 * 80)
         self.create_regular_file("file333", size=1024 * 80)
 
-        self.cmd(f'--repo={self.repository_location}', 'create', "test", "input")
+        # Create with regular expression exclusion for file4
+        self.cmd(f"--repo={self.repository_location}", "create", "--exclude=re:input/file4$", "test", "input")
+        with changedir("output"):
+            self.cmd(f"--repo={self.repository_location}", "extract", "test")
+        self.assert_equal(sorted(os.listdir("output/input")), ["file1", "file2", "file3", "file333"])
+        shutil.rmtree("output/input")
+
+        # Extract with regular expression exclusion
+        with changedir("output"):
+            self.cmd(f"--repo={self.repository_location}", "extract", "test", "--exclude=re:file3+")
+        self.assert_equal(sorted(os.listdir("output/input")), ["file1", "file2"])
+        shutil.rmtree("output/input")
+
+        # Combine --exclude with fnmatch and regular expression
+        with changedir("output"):
+            self.cmd(
+                f"--repo={self.repository_location}",
+                "extract",
+                "test",
+                "--exclude=input/file2",
+                "--exclude=re:file[01]",
+            )
+        self.assert_equal(sorted(os.listdir("output/input")), ["file3", "file333"])
+        shutil.rmtree("output/input")
+
+        # Combine --exclude-from and regular expression exclusion
+        with changedir("output"):
+            self.cmd(
+                f"--repo={self.repository_location}",
+                "extract",
+                "test",
+                "--exclude-from=" + self.exclude_file_path,
+                "--exclude=re:file1",
+                "--exclude=re:file(\\d)\\1\\1$",
+            )
+        self.assert_equal(sorted(os.listdir("output/input")), ["file3"])
+
+    def test_extract_include_exclude_regex_from_file(self):
+        self.cmd(f"--repo={self.repository_location}", "rcreate", RK_ENCRYPTION)
+        self.create_regular_file("file1", size=1024 * 80)
+        self.create_regular_file("file2", size=1024 * 80)
+        self.create_regular_file("file3", size=1024 * 80)
+        self.create_regular_file("file4", size=1024 * 80)
+        self.create_regular_file("file333", size=1024 * 80)
+        self.create_regular_file("aa:something", size=1024 * 80)
+
+        # Create while excluding using mixed pattern styles
+        with open(self.exclude_file_path, "wb") as fd:
+            fd.write(b"re:input/file4$\n")
+            fd.write(b"fm:*aa:*thing\n")
+
+        self.cmd(
+            f"--repo={self.repository_location}", "create", "--exclude-from=" + self.exclude_file_path, "test", "input"
+        )
+        with changedir("output"):
+            self.cmd(f"--repo={self.repository_location}", "extract", "test")
+        self.assert_equal(sorted(os.listdir("output/input")), ["file1", "file2", "file3", "file333"])
+        shutil.rmtree("output/input")
+
+        # Exclude using regular expression
+        with open(self.exclude_file_path, "wb") as fd:
+            fd.write(b"re:file3+\n")
+
+        with changedir("output"):
+            self.cmd(
+                f"--repo={self.repository_location}", "extract", "test", "--exclude-from=" + self.exclude_file_path
+            )
+        self.assert_equal(sorted(os.listdir("output/input")), ["file1", "file2"])
+        shutil.rmtree("output/input")
+
+        # Mixed exclude pattern styles
+        with open(self.exclude_file_path, "wb") as fd:
+            fd.write(b"re:file(\\d)\\1\\1$\n")
+            fd.write(b"fm:nothingwillmatchthis\n")
+            fd.write(b"*/file1\n")
+            fd.write(b"re:file2$\n")
+
+        with changedir("output"):
+            self.cmd(
+                f"--repo={self.repository_location}", "extract", "test", "--exclude-from=" + self.exclude_file_path
+            )
+        self.assert_equal(sorted(os.listdir("output/input")), ["file3"])
+
+    def test_extract_with_pattern(self):
+        self.cmd(f"--repo={self.repository_location}", "rcreate", RK_ENCRYPTION)
+        self.create_regular_file("file1", size=1024 * 80)
+        self.create_regular_file("file2", size=1024 * 80)
+        self.create_regular_file("file3", size=1024 * 80)
+        self.create_regular_file("file4", size=1024 * 80)
+        self.create_regular_file("file333", size=1024 * 80)
+
+        self.cmd(f"--repo={self.repository_location}", "create", "test", "input")
 
         # Extract everything with regular expression
         with changedir("output"):
-            self.cmd(f'--repo={self.repository_location}', "extract", "test", "re:.*")
+            self.cmd(f"--repo={self.repository_location}", "extract", "test", "re:.*")
         self.assert_equal(sorted(os.listdir("output/input")), ["file1", "file2", "file3", "file333", "file4"])
         shutil.rmtree("output/input")
 
         # Extract with pattern while also excluding files
         with changedir("output"):
-            self.cmd(f'--repo={self.repository_location}', "extract", "--exclude=re:file[34]$", "test", r"re:file\d$")
+            self.cmd(f"--repo={self.repository_location}", "extract", "--exclude=re:file[34]$", "test", r"re:file\d$")
         self.assert_equal(sorted(os.listdir("output/input")), ["file1", "file2"])
         shutil.rmtree("output/input")
 
         # Combine --exclude with pattern for extraction
         with changedir("output"):
-            self.cmd(f'--repo={self.repository_location}', "extract", "--exclude=input/file1", "test", "re:file[12]$")
+            self.cmd(f"--repo={self.repository_location}", "extract", "--exclude=input/file1", "test", "re:file[12]$")
         self.assert_equal(sorted(os.listdir("output/input")), ["file2"])
         shutil.rmtree("output/input")
 
         # Multiple pattern
         with changedir("output"):
-            self.cmd(f'--repo={self.repository_location}', "extract", "test", "fm:input/file1", "fm:*file33*", "input/file2")
+            self.cmd(
+                f"--repo={self.repository_location}", "extract", "test", "fm:input/file1", "fm:*file33*", "input/file2"
+            )
         self.assert_equal(sorted(os.listdir("output/input")), ["file1", "file2", "file333"])
 
     def test_extract_list_output(self):
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
-        self.create_regular_file('file', size=1024 * 80)
+        self.cmd(f"--repo={self.repository_location}", "rcreate", RK_ENCRYPTION)
+        self.create_regular_file("file", size=1024 * 80)
 
-        self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
+        self.cmd(f"--repo={self.repository_location}", "create", "test", "input")
 
-        with changedir('output'):
-            output = self.cmd(f'--repo={self.repository_location}', 'extract', 'test')
+        with changedir("output"):
+            output = self.cmd(f"--repo={self.repository_location}", "extract", "test")
         self.assert_not_in("input/file", output)
-        shutil.rmtree('output/input')
+        shutil.rmtree("output/input")
 
-        with changedir('output'):
-            output = self.cmd(f'--repo={self.repository_location}', 'extract', 'test', '--info')
+        with changedir("output"):
+            output = self.cmd(f"--repo={self.repository_location}", "extract", "test", "--info")
         self.assert_not_in("input/file", output)
-        shutil.rmtree('output/input')
+        shutil.rmtree("output/input")
 
-        with changedir('output'):
-            output = self.cmd(f'--repo={self.repository_location}', 'extract', 'test', '--list')
+        with changedir("output"):
+            output = self.cmd(f"--repo={self.repository_location}", "extract", "test", "--list")
         self.assert_in("input/file", output)
-        shutil.rmtree('output/input')
+        shutil.rmtree("output/input")
 
-        with changedir('output'):
-            output = self.cmd(f'--repo={self.repository_location}', 'extract', 'test', '--list', '--info')
+        with changedir("output"):
+            output = self.cmd(f"--repo={self.repository_location}", "extract", "test", "--list", "--info")
         self.assert_in("input/file", output)
 
     def test_extract_progress(self):
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
-        self.create_regular_file('file', size=1024 * 80)
-        self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
+        self.cmd(f"--repo={self.repository_location}", "rcreate", RK_ENCRYPTION)
+        self.create_regular_file("file", size=1024 * 80)
+        self.cmd(f"--repo={self.repository_location}", "create", "test", "input")
 
-        with changedir('output'):
-            output = self.cmd(f'--repo={self.repository_location}', 'extract', 'test', '--progress')
-            assert 'Extracting:' in output
+        with changedir("output"):
+            output = self.cmd(f"--repo={self.repository_location}", "extract", "test", "--progress")
+            assert "Extracting:" in output
 
     def _create_test_caches(self):
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
-        self.create_regular_file('file1', size=1024 * 80)
-        self.create_regular_file('cache1/%s' % CACHE_TAG_NAME,
-                                 contents=CACHE_TAG_CONTENTS + b' extra stuff')
-        self.create_regular_file('cache2/%s' % CACHE_TAG_NAME,
-                                 contents=b'invalid signature')
-        os.mkdir('input/cache3')
+        self.cmd(f"--repo={self.repository_location}", "rcreate", RK_ENCRYPTION)
+        self.create_regular_file("file1", size=1024 * 80)
+        self.create_regular_file("cache1/%s" % CACHE_TAG_NAME, contents=CACHE_TAG_CONTENTS + b" extra stuff")
+        self.create_regular_file("cache2/%s" % CACHE_TAG_NAME, contents=b"invalid signature")
+        os.mkdir("input/cache3")
         if are_hardlinks_supported():
-            os.link('input/cache1/%s' % CACHE_TAG_NAME, 'input/cache3/%s' % CACHE_TAG_NAME)
+            os.link("input/cache1/%s" % CACHE_TAG_NAME, "input/cache3/%s" % CACHE_TAG_NAME)
         else:
-            self.create_regular_file('cache3/%s' % CACHE_TAG_NAME,
-                                     contents=CACHE_TAG_CONTENTS + b' extra stuff')
+            self.create_regular_file("cache3/%s" % CACHE_TAG_NAME, contents=CACHE_TAG_CONTENTS + b" extra stuff")
 
     def test_create_stdin(self):
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
-        input_data = b'\x00foo\n\nbar\n   \n'
-        self.cmd(f'--repo={self.repository_location}', 'create', 'test', '-', input=input_data)
-        item = json.loads(self.cmd(f'--repo={self.repository_location}', 'list', 'test', '--json-lines'))
-        assert item['uid'] == 0
-        assert item['gid'] == 0
-        assert item['size'] == len(input_data)
-        assert item['path'] == 'stdin'
-        extracted_data = self.cmd(f'--repo={self.repository_location}', 'extract', 'test', '--stdout', binary_output=True)
+        self.cmd(f"--repo={self.repository_location}", "rcreate", RK_ENCRYPTION)
+        input_data = b"\x00foo\n\nbar\n   \n"
+        self.cmd(f"--repo={self.repository_location}", "create", "test", "-", input=input_data)
+        item = json.loads(self.cmd(f"--repo={self.repository_location}", "list", "test", "--json-lines"))
+        assert item["uid"] == 0
+        assert item["gid"] == 0
+        assert item["size"] == len(input_data)
+        assert item["path"] == "stdin"
+        extracted_data = self.cmd(
+            f"--repo={self.repository_location}", "extract", "test", "--stdout", binary_output=True
+        )
         assert extracted_data == input_data
 
     def test_create_content_from_command(self):
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
-        input_data = 'some test content'
-        name = 'a/b/c'
-        self.cmd(f'--repo={self.repository_location}', 'create', '--stdin-name', name, '--content-from-command',
-                 'test', '--', 'echo', input_data)
-        item = json.loads(self.cmd(f'--repo={self.repository_location}', 'list', 'test', '--json-lines'))
-        assert item['uid'] == 0
-        assert item['gid'] == 0
-        assert item['size'] == len(input_data) + 1  # `echo` adds newline
-        assert item['path'] == name
-        extracted_data = self.cmd(f'--repo={self.repository_location}', 'extract', 'test', '--stdout')
-        assert extracted_data == input_data + '\n'
+        self.cmd(f"--repo={self.repository_location}", "rcreate", RK_ENCRYPTION)
+        input_data = "some test content"
+        name = "a/b/c"
+        self.cmd(
+            f"--repo={self.repository_location}",
+            "create",
+            "--stdin-name",
+            name,
+            "--content-from-command",
+            "test",
+            "--",
+            "echo",
+            input_data,
+        )
+        item = json.loads(self.cmd(f"--repo={self.repository_location}", "list", "test", "--json-lines"))
+        assert item["uid"] == 0
+        assert item["gid"] == 0
+        assert item["size"] == len(input_data) + 1  # `echo` adds newline
+        assert item["path"] == name
+        extracted_data = self.cmd(f"--repo={self.repository_location}", "extract", "test", "--stdout")
+        assert extracted_data == input_data + "\n"
 
     def test_create_content_from_command_with_failed_command(self):
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
-        output = self.cmd(f'--repo={self.repository_location}', 'create', '--content-from-command', 'test',
-                          '--', 'sh', '-c', 'exit 73;', exit_code=2)
+        self.cmd(f"--repo={self.repository_location}", "rcreate", RK_ENCRYPTION)
+        output = self.cmd(
+            f"--repo={self.repository_location}",
+            "create",
+            "--content-from-command",
+            "test",
+            "--",
+            "sh",
+            "-c",
+            "exit 73;",
+            exit_code=2,
+        )
         assert output.endswith("Command 'sh' exited with status 73\n")
-        archive_list = json.loads(self.cmd(f'--repo={self.repository_location}', 'rlist', '--json'))
-        assert archive_list['archives'] == []
+        archive_list = json.loads(self.cmd(f"--repo={self.repository_location}", "rlist", "--json"))
+        assert archive_list["archives"] == []
 
     def test_create_content_from_command_missing_command(self):
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
-        output = self.cmd(f'--repo={self.repository_location}', 'create', 'test', '--content-from-command', exit_code=2)
-        assert output.endswith('No command given.\n')
+        self.cmd(f"--repo={self.repository_location}", "rcreate", RK_ENCRYPTION)
+        output = self.cmd(f"--repo={self.repository_location}", "create", "test", "--content-from-command", exit_code=2)
+        assert output.endswith("No command given.\n")
 
     def test_create_paths_from_stdin(self):
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
+        self.cmd(f"--repo={self.repository_location}", "rcreate", RK_ENCRYPTION)
         self.create_regular_file("file1", size=1024 * 80)
         self.create_regular_file("dir1/file2", size=1024 * 80)
         self.create_regular_file("dir1/file3", size=1024 * 80)
         self.create_regular_file("file4", size=1024 * 80)
 
-        input_data = b'input/file1\0input/dir1\0input/file4'
-        self.cmd(f'--repo={self.repository_location}', 'create', 'test',
-                 '--paths-from-stdin', '--paths-delimiter', '\\0', input=input_data)
-        archive_list = self.cmd(f'--repo={self.repository_location}', 'list', 'test', '--json-lines')
-        paths = [json.loads(line)['path'] for line in archive_list.split('\n') if line]
-        assert paths == ['input/file1', 'input/dir1', 'input/file4']
+        input_data = b"input/file1\0input/dir1\0input/file4"
+        self.cmd(
+            f"--repo={self.repository_location}",
+            "create",
+            "test",
+            "--paths-from-stdin",
+            "--paths-delimiter",
+            "\\0",
+            input=input_data,
+        )
+        archive_list = self.cmd(f"--repo={self.repository_location}", "list", "test", "--json-lines")
+        paths = [json.loads(line)["path"] for line in archive_list.split("\n") if line]
+        assert paths == ["input/file1", "input/dir1", "input/file4"]
 
     def test_create_paths_from_command(self):
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
+        self.cmd(f"--repo={self.repository_location}", "rcreate", RK_ENCRYPTION)
         self.create_regular_file("file1", size=1024 * 80)
         self.create_regular_file("file2", size=1024 * 80)
         self.create_regular_file("file3", size=1024 * 80)
         self.create_regular_file("file4", size=1024 * 80)
 
-        input_data = 'input/file1\ninput/file2\ninput/file3'
-        self.cmd(f'--repo={self.repository_location}', 'create', '--paths-from-command', 'test',
-                 '--', 'echo', input_data)
-        archive_list = self.cmd(f'--repo={self.repository_location}', 'list', 'test', '--json-lines')
-        paths = [json.loads(line)['path'] for line in archive_list.split('\n') if line]
-        assert paths == ['input/file1', 'input/file2', 'input/file3']
+        input_data = "input/file1\ninput/file2\ninput/file3"
+        self.cmd(
+            f"--repo={self.repository_location}", "create", "--paths-from-command", "test", "--", "echo", input_data
+        )
+        archive_list = self.cmd(f"--repo={self.repository_location}", "list", "test", "--json-lines")
+        paths = [json.loads(line)["path"] for line in archive_list.split("\n") if line]
+        assert paths == ["input/file1", "input/file2", "input/file3"]
 
     def test_create_paths_from_command_with_failed_command(self):
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
-        output = self.cmd(f'--repo={self.repository_location}', 'create', '--paths-from-command', 'test',
-                          '--', 'sh', '-c', 'exit 73;', exit_code=2)
+        self.cmd(f"--repo={self.repository_location}", "rcreate", RK_ENCRYPTION)
+        output = self.cmd(
+            f"--repo={self.repository_location}",
+            "create",
+            "--paths-from-command",
+            "test",
+            "--",
+            "sh",
+            "-c",
+            "exit 73;",
+            exit_code=2,
+        )
         assert output.endswith("Command 'sh' exited with status 73\n")
-        archive_list = json.loads(self.cmd(f'--repo={self.repository_location}', 'rlist', '--json'))
-        assert archive_list['archives'] == []
+        archive_list = json.loads(self.cmd(f"--repo={self.repository_location}", "rlist", "--json"))
+        assert archive_list["archives"] == []
 
     def test_create_paths_from_command_missing_command(self):
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
-        output = self.cmd(f'--repo={self.repository_location}', 'create', 'test', '--paths-from-command', exit_code=2)
-        assert output.endswith('No command given.\n')
+        self.cmd(f"--repo={self.repository_location}", "rcreate", RK_ENCRYPTION)
+        output = self.cmd(f"--repo={self.repository_location}", "create", "test", "--paths-from-command", exit_code=2)
+        assert output.endswith("No command given.\n")
 
     def test_create_without_root(self):
         """test create without a root"""
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
-        self.cmd(f'--repo={self.repository_location}', 'create', 'test', exit_code=2)
+        self.cmd(f"--repo={self.repository_location}", "rcreate", RK_ENCRYPTION)
+        self.cmd(f"--repo={self.repository_location}", "create", "test", exit_code=2)
 
     def test_create_pattern_root(self):
         """test create with only a root pattern"""
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
-        self.create_regular_file('file1', size=1024 * 80)
-        self.create_regular_file('file2', size=1024 * 80)
-        output = self.cmd(f'--repo={self.repository_location}', 'create', 'test', '-v', '--list', '--pattern=R input')
+        self.cmd(f"--repo={self.repository_location}", "rcreate", RK_ENCRYPTION)
+        self.create_regular_file("file1", size=1024 * 80)
+        self.create_regular_file("file2", size=1024 * 80)
+        output = self.cmd(f"--repo={self.repository_location}", "create", "test", "-v", "--list", "--pattern=R input")
         self.assert_in("A input/file1", output)
         self.assert_in("A input/file2", output)
 
     def test_create_pattern(self):
         """test file patterns during create"""
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
-        self.create_regular_file('file1', size=1024 * 80)
-        self.create_regular_file('file2', size=1024 * 80)
-        self.create_regular_file('file_important', size=1024 * 80)
-        output = self.cmd(f'--repo={self.repository_location}', 'create', '-v', '--list',
-                          '--pattern=+input/file_important', '--pattern=-input/file*',
-                          'test', 'input')
+        self.cmd(f"--repo={self.repository_location}", "rcreate", RK_ENCRYPTION)
+        self.create_regular_file("file1", size=1024 * 80)
+        self.create_regular_file("file2", size=1024 * 80)
+        self.create_regular_file("file_important", size=1024 * 80)
+        output = self.cmd(
+            f"--repo={self.repository_location}",
+            "create",
+            "-v",
+            "--list",
+            "--pattern=+input/file_important",
+            "--pattern=-input/file*",
+            "test",
+            "input",
+        )
         self.assert_in("A input/file_important", output)
-        self.assert_in('x input/file1', output)
-        self.assert_in('x input/file2', output)
+        self.assert_in("x input/file1", output)
+        self.assert_in("x input/file2", output)
 
     def test_create_pattern_file(self):
         """test file patterns during create"""
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
-        self.create_regular_file('file1', size=1024 * 80)
-        self.create_regular_file('file2', size=1024 * 80)
-        self.create_regular_file('otherfile', size=1024 * 80)
-        self.create_regular_file('file_important', size=1024 * 80)
-        output = self.cmd(f'--repo={self.repository_location}', 'create', '-v', '--list',
-                          '--pattern=-input/otherfile', '--patterns-from=' + self.patterns_file_path,
-                          'test', 'input')
+        self.cmd(f"--repo={self.repository_location}", "rcreate", RK_ENCRYPTION)
+        self.create_regular_file("file1", size=1024 * 80)
+        self.create_regular_file("file2", size=1024 * 80)
+        self.create_regular_file("otherfile", size=1024 * 80)
+        self.create_regular_file("file_important", size=1024 * 80)
+        output = self.cmd(
+            f"--repo={self.repository_location}",
+            "create",
+            "-v",
+            "--list",
+            "--pattern=-input/otherfile",
+            "--patterns-from=" + self.patterns_file_path,
+            "test",
+            "input",
+        )
         self.assert_in("A input/file_important", output)
-        self.assert_in('x input/file1', output)
-        self.assert_in('x input/file2', output)
-        self.assert_in('x input/otherfile', output)
+        self.assert_in("x input/file1", output)
+        self.assert_in("x input/file2", output)
+        self.assert_in("x input/otherfile", output)
 
     def test_create_pattern_exclude_folder_but_recurse(self):
         """test when patterns exclude a parent folder, but include a child"""
-        self.patterns_file_path2 = os.path.join(self.tmpdir, 'patterns2')
-        with open(self.patterns_file_path2, 'wb') as fd:
-            fd.write(b'+ input/x/b\n- input/x*\n')
+        self.patterns_file_path2 = os.path.join(self.tmpdir, "patterns2")
+        with open(self.patterns_file_path2, "wb") as fd:
+            fd.write(b"+ input/x/b\n- input/x*\n")
 
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
-        self.create_regular_file('x/a/foo_a', size=1024 * 80)
-        self.create_regular_file('x/b/foo_b', size=1024 * 80)
-        self.create_regular_file('y/foo_y', size=1024 * 80)
-        output = self.cmd(f'--repo={self.repository_location}', 'create', '-v', '--list',
-                          '--patterns-from=' + self.patterns_file_path2,
-                          'test', 'input')
-        self.assert_in('x input/x/a/foo_a', output)
+        self.cmd(f"--repo={self.repository_location}", "rcreate", RK_ENCRYPTION)
+        self.create_regular_file("x/a/foo_a", size=1024 * 80)
+        self.create_regular_file("x/b/foo_b", size=1024 * 80)
+        self.create_regular_file("y/foo_y", size=1024 * 80)
+        output = self.cmd(
+            f"--repo={self.repository_location}",
+            "create",
+            "-v",
+            "--list",
+            "--patterns-from=" + self.patterns_file_path2,
+            "test",
+            "input",
+        )
+        self.assert_in("x input/x/a/foo_a", output)
         self.assert_in("A input/x/b/foo_b", output)
-        self.assert_in('A input/y/foo_y', output)
+        self.assert_in("A input/y/foo_y", output)
 
     def test_create_pattern_exclude_folder_no_recurse(self):
         """test when patterns exclude a parent folder and, but include a child"""
-        self.patterns_file_path2 = os.path.join(self.tmpdir, 'patterns2')
-        with open(self.patterns_file_path2, 'wb') as fd:
-            fd.write(b'+ input/x/b\n! input/x*\n')
+        self.patterns_file_path2 = os.path.join(self.tmpdir, "patterns2")
+        with open(self.patterns_file_path2, "wb") as fd:
+            fd.write(b"+ input/x/b\n! input/x*\n")
 
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
-        self.create_regular_file('x/a/foo_a', size=1024 * 80)
-        self.create_regular_file('x/b/foo_b', size=1024 * 80)
-        self.create_regular_file('y/foo_y', size=1024 * 80)
-        output = self.cmd(f'--repo={self.repository_location}', 'create', '-v', '--list',
-                          '--patterns-from=' + self.patterns_file_path2,
-                          'test', 'input')
-        self.assert_not_in('input/x/a/foo_a', output)
-        self.assert_not_in('input/x/a', output)
-        self.assert_in('A input/y/foo_y', output)
+        self.cmd(f"--repo={self.repository_location}", "rcreate", RK_ENCRYPTION)
+        self.create_regular_file("x/a/foo_a", size=1024 * 80)
+        self.create_regular_file("x/b/foo_b", size=1024 * 80)
+        self.create_regular_file("y/foo_y", size=1024 * 80)
+        output = self.cmd(
+            f"--repo={self.repository_location}",
+            "create",
+            "-v",
+            "--list",
+            "--patterns-from=" + self.patterns_file_path2,
+            "test",
+            "input",
+        )
+        self.assert_not_in("input/x/a/foo_a", output)
+        self.assert_not_in("input/x/a", output)
+        self.assert_in("A input/y/foo_y", output)
 
     def test_create_pattern_intermediate_folders_first(self):
         """test that intermediate folders appear first when patterns exclude a parent folder but include a child"""
-        self.patterns_file_path2 = os.path.join(self.tmpdir, 'patterns2')
-        with open(self.patterns_file_path2, 'wb') as fd:
-            fd.write(b'+ input/x/a\n+ input/x/b\n- input/x*\n')
+        self.patterns_file_path2 = os.path.join(self.tmpdir, "patterns2")
+        with open(self.patterns_file_path2, "wb") as fd:
+            fd.write(b"+ input/x/a\n+ input/x/b\n- input/x*\n")
 
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
+        self.cmd(f"--repo={self.repository_location}", "rcreate", RK_ENCRYPTION)
 
-        self.create_regular_file('x/a/foo_a', size=1024 * 80)
-        self.create_regular_file('x/b/foo_b', size=1024 * 80)
-        with changedir('input'):
-            self.cmd(f'--repo={self.repository_location}', 'create', '--patterns-from=' + self.patterns_file_path2,
-                     'test', '.')
+        self.create_regular_file("x/a/foo_a", size=1024 * 80)
+        self.create_regular_file("x/b/foo_b", size=1024 * 80)
+        with changedir("input"):
+            self.cmd(
+                f"--repo={self.repository_location}",
+                "create",
+                "--patterns-from=" + self.patterns_file_path2,
+                "test",
+                ".",
+            )
 
         # list the archive and verify that the "intermediate" folders appear before
         # their contents
-        out = self.cmd(f'--repo={self.repository_location}', 'list', 'test', '--format', '{type} {path}{NL}')
+        out = self.cmd(f"--repo={self.repository_location}", "list", "test", "--format", "{type} {path}{NL}")
         out_list = out.splitlines()
 
-        self.assert_in('d x/a', out_list)
-        self.assert_in('d x/b', out_list)
+        self.assert_in("d x/a", out_list)
+        self.assert_in("d x/b", out_list)
 
-        assert out_list.index('d x/a') < out_list.index('- x/a/foo_a')
-        assert out_list.index('d x/b') < out_list.index('- x/b/foo_b')
+        assert out_list.index("d x/a") < out_list.index("- x/a/foo_a")
+        assert out_list.index("d x/b") < out_list.index("- x/b/foo_b")
 
     def test_create_no_cache_sync(self):
         self.create_test_files()
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
-        self.cmd(f'--repo={self.repository_location}', 'rdelete', '--cache-only')
-        create_json = json.loads(self.cmd(f'--repo={self.repository_location}', 'create',
-                                          '--no-cache-sync', '--json', '--error',
-                                          'test', 'input'))  # ignore experimental warning
-        info_json = json.loads(self.cmd(f'--repo={self.repository_location}', 'info', '-a', 'test', '--json'))
-        create_stats = create_json['cache']['stats']
-        info_stats = info_json['cache']['stats']
+        self.cmd(f"--repo={self.repository_location}", "rcreate", RK_ENCRYPTION)
+        self.cmd(f"--repo={self.repository_location}", "rdelete", "--cache-only")
+        create_json = json.loads(
+            self.cmd(
+                f"--repo={self.repository_location}", "create", "--no-cache-sync", "--json", "--error", "test", "input"
+            )
+        )  # ignore experimental warning
+        info_json = json.loads(self.cmd(f"--repo={self.repository_location}", "info", "-a", "test", "--json"))
+        create_stats = create_json["cache"]["stats"]
+        info_stats = info_json["cache"]["stats"]
         assert create_stats == info_stats
-        self.cmd(f'--repo={self.repository_location}', 'rdelete', '--cache-only')
-        self.cmd(f'--repo={self.repository_location}', 'create', '--no-cache-sync', 'test2', 'input')
-        self.cmd(f'--repo={self.repository_location}', 'rinfo')
-        self.cmd(f'--repo={self.repository_location}', 'check')
+        self.cmd(f"--repo={self.repository_location}", "rdelete", "--cache-only")
+        self.cmd(f"--repo={self.repository_location}", "create", "--no-cache-sync", "test2", "input")
+        self.cmd(f"--repo={self.repository_location}", "rinfo")
+        self.cmd(f"--repo={self.repository_location}", "check")
 
     def test_extract_pattern_opt(self):
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
-        self.create_regular_file('file1', size=1024 * 80)
-        self.create_regular_file('file2', size=1024 * 80)
-        self.create_regular_file('file_important', size=1024 * 80)
-        self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
-        with changedir('output'):
-            self.cmd(f'--repo={self.repository_location}', 'extract', 'test',
-                     '--pattern=+input/file_important', '--pattern=-input/file*')
-        self.assert_equal(sorted(os.listdir('output/input')), ['file_important'])
+        self.cmd(f"--repo={self.repository_location}", "rcreate", RK_ENCRYPTION)
+        self.create_regular_file("file1", size=1024 * 80)
+        self.create_regular_file("file2", size=1024 * 80)
+        self.create_regular_file("file_important", size=1024 * 80)
+        self.cmd(f"--repo={self.repository_location}", "create", "test", "input")
+        with changedir("output"):
+            self.cmd(
+                f"--repo={self.repository_location}",
+                "extract",
+                "test",
+                "--pattern=+input/file_important",
+                "--pattern=-input/file*",
+            )
+        self.assert_equal(sorted(os.listdir("output/input")), ["file_important"])
 
     def _assert_test_caches(self):
-        with changedir('output'):
-            self.cmd(f'--repo={self.repository_location}', 'extract', 'test')
-        self.assert_equal(sorted(os.listdir('output/input')), ['cache2', 'file1'])
-        self.assert_equal(sorted(os.listdir('output/input/cache2')), [CACHE_TAG_NAME])
+        with changedir("output"):
+            self.cmd(f"--repo={self.repository_location}", "extract", "test")
+        self.assert_equal(sorted(os.listdir("output/input")), ["cache2", "file1"])
+        self.assert_equal(sorted(os.listdir("output/input/cache2")), [CACHE_TAG_NAME])
 
     def test_exclude_caches(self):
         self._create_test_caches()
-        self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input', '--exclude-caches')
+        self.cmd(f"--repo={self.repository_location}", "create", "test", "input", "--exclude-caches")
         self._assert_test_caches()
 
     def test_recreate_exclude_caches(self):
         self._create_test_caches()
-        self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
-        self.cmd(f'--repo={self.repository_location}', 'recreate', '-a', 'test', '--exclude-caches')
+        self.cmd(f"--repo={self.repository_location}", "create", "test", "input")
+        self.cmd(f"--repo={self.repository_location}", "recreate", "-a", "test", "--exclude-caches")
         self._assert_test_caches()
 
     def _create_test_tagged(self):
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
-        self.create_regular_file('file1', size=1024 * 80)
-        self.create_regular_file('tagged1/.NOBACKUP')
-        self.create_regular_file('tagged2/00-NOBACKUP')
-        self.create_regular_file('tagged3/.NOBACKUP/file2', size=1024)
+        self.cmd(f"--repo={self.repository_location}", "rcreate", RK_ENCRYPTION)
+        self.create_regular_file("file1", size=1024 * 80)
+        self.create_regular_file("tagged1/.NOBACKUP")
+        self.create_regular_file("tagged2/00-NOBACKUP")
+        self.create_regular_file("tagged3/.NOBACKUP/file2", size=1024)
 
     def _assert_test_tagged(self):
-        with changedir('output'):
-            self.cmd(f'--repo={self.repository_location}', 'extract', 'test')
-        self.assert_equal(sorted(os.listdir('output/input')), ['file1'])
+        with changedir("output"):
+            self.cmd(f"--repo={self.repository_location}", "extract", "test")
+        self.assert_equal(sorted(os.listdir("output/input")), ["file1"])
 
     def test_exclude_tagged(self):
         self._create_test_tagged()
-        self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input',
-                 '--exclude-if-present', '.NOBACKUP', '--exclude-if-present', '00-NOBACKUP')
+        self.cmd(
+            f"--repo={self.repository_location}",
+            "create",
+            "test",
+            "input",
+            "--exclude-if-present",
+            ".NOBACKUP",
+            "--exclude-if-present",
+            "00-NOBACKUP",
+        )
         self._assert_test_tagged()
 
     def test_recreate_exclude_tagged(self):
         self._create_test_tagged()
-        self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
-        self.cmd(f'--repo={self.repository_location}', 'recreate', '-a', 'test', '--exclude-if-present', '.NOBACKUP',
-                 '--exclude-if-present', '00-NOBACKUP')
+        self.cmd(f"--repo={self.repository_location}", "create", "test", "input")
+        self.cmd(
+            f"--repo={self.repository_location}",
+            "recreate",
+            "-a",
+            "test",
+            "--exclude-if-present",
+            ".NOBACKUP",
+            "--exclude-if-present",
+            "00-NOBACKUP",
+        )
         self._assert_test_tagged()
 
     def _create_test_keep_tagged(self):
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
-        self.create_regular_file('file0', size=1024)
-        self.create_regular_file('tagged1/.NOBACKUP1')
-        self.create_regular_file('tagged1/file1', size=1024)
-        self.create_regular_file('tagged2/.NOBACKUP2/subfile1', size=1024)
-        self.create_regular_file('tagged2/file2', size=1024)
-        self.create_regular_file('tagged3/%s' % CACHE_TAG_NAME,
-                                 contents=CACHE_TAG_CONTENTS + b' extra stuff')
-        self.create_regular_file('tagged3/file3', size=1024)
-        self.create_regular_file('taggedall/.NOBACKUP1')
-        self.create_regular_file('taggedall/.NOBACKUP2/subfile1', size=1024)
-        self.create_regular_file('taggedall/%s' % CACHE_TAG_NAME,
-                                 contents=CACHE_TAG_CONTENTS + b' extra stuff')
-        self.create_regular_file('taggedall/file4', size=1024)
+        self.cmd(f"--repo={self.repository_location}", "rcreate", RK_ENCRYPTION)
+        self.create_regular_file("file0", size=1024)
+        self.create_regular_file("tagged1/.NOBACKUP1")
+        self.create_regular_file("tagged1/file1", size=1024)
+        self.create_regular_file("tagged2/.NOBACKUP2/subfile1", size=1024)
+        self.create_regular_file("tagged2/file2", size=1024)
+        self.create_regular_file("tagged3/%s" % CACHE_TAG_NAME, contents=CACHE_TAG_CONTENTS + b" extra stuff")
+        self.create_regular_file("tagged3/file3", size=1024)
+        self.create_regular_file("taggedall/.NOBACKUP1")
+        self.create_regular_file("taggedall/.NOBACKUP2/subfile1", size=1024)
+        self.create_regular_file("taggedall/%s" % CACHE_TAG_NAME, contents=CACHE_TAG_CONTENTS + b" extra stuff")
+        self.create_regular_file("taggedall/file4", size=1024)
 
     def _assert_test_keep_tagged(self):
-        with changedir('output'):
-            self.cmd(f'--repo={self.repository_location}', 'extract', 'test')
-        self.assert_equal(sorted(os.listdir('output/input')), ['file0', 'tagged1', 'tagged2', 'tagged3', 'taggedall'])
-        self.assert_equal(os.listdir('output/input/tagged1'), ['.NOBACKUP1'])
-        self.assert_equal(os.listdir('output/input/tagged2'), ['.NOBACKUP2'])
-        self.assert_equal(os.listdir('output/input/tagged3'), [CACHE_TAG_NAME])
-        self.assert_equal(sorted(os.listdir('output/input/taggedall')),
-                          ['.NOBACKUP1', '.NOBACKUP2', CACHE_TAG_NAME, ])
+        with changedir("output"):
+            self.cmd(f"--repo={self.repository_location}", "extract", "test")
+        self.assert_equal(sorted(os.listdir("output/input")), ["file0", "tagged1", "tagged2", "tagged3", "taggedall"])
+        self.assert_equal(os.listdir("output/input/tagged1"), [".NOBACKUP1"])
+        self.assert_equal(os.listdir("output/input/tagged2"), [".NOBACKUP2"])
+        self.assert_equal(os.listdir("output/input/tagged3"), [CACHE_TAG_NAME])
+        self.assert_equal(sorted(os.listdir("output/input/taggedall")), [".NOBACKUP1", ".NOBACKUP2", CACHE_TAG_NAME])
 
     def test_exclude_keep_tagged(self):
         self._create_test_keep_tagged()
-        self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input', '--exclude-if-present', '.NOBACKUP1',
-                 '--exclude-if-present', '.NOBACKUP2', '--exclude-caches', '--keep-exclude-tags')
+        self.cmd(
+            f"--repo={self.repository_location}",
+            "create",
+            "test",
+            "input",
+            "--exclude-if-present",
+            ".NOBACKUP1",
+            "--exclude-if-present",
+            ".NOBACKUP2",
+            "--exclude-caches",
+            "--keep-exclude-tags",
+        )
         self._assert_test_keep_tagged()
 
     def test_recreate_exclude_keep_tagged(self):
         self._create_test_keep_tagged()
-        self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
-        self.cmd(f'--repo={self.repository_location}', 'recreate', '-a', 'test', '--exclude-if-present', '.NOBACKUP1',
-                 '--exclude-if-present', '.NOBACKUP2', '--exclude-caches', '--keep-exclude-tags')
+        self.cmd(f"--repo={self.repository_location}", "create", "test", "input")
+        self.cmd(
+            f"--repo={self.repository_location}",
+            "recreate",
+            "-a",
+            "test",
+            "--exclude-if-present",
+            ".NOBACKUP1",
+            "--exclude-if-present",
+            ".NOBACKUP2",
+            "--exclude-caches",
+            "--keep-exclude-tags",
+        )
         self._assert_test_keep_tagged()
 
-    @pytest.mark.skipif(not are_hardlinks_supported(), reason='hardlinks not supported')
+    @pytest.mark.skipif(not are_hardlinks_supported(), reason="hardlinks not supported")
     def test_recreate_hardlinked_tags(self):  # test for issue #4911
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=none')
-        self.create_regular_file('file1', contents=CACHE_TAG_CONTENTS)  # "wrong" filename, but correct tag contents
-        os.mkdir(os.path.join(self.input_path, 'subdir'))  # to make sure the tag is encountered *after* file1
-        os.link(os.path.join(self.input_path, 'file1'),
-                os.path.join(self.input_path, 'subdir', CACHE_TAG_NAME))  # correct tag name, hardlink to file1
-        self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
+        self.cmd(f"--repo={self.repository_location}", "rcreate", "--encryption=none")
+        self.create_regular_file("file1", contents=CACHE_TAG_CONTENTS)  # "wrong" filename, but correct tag contents
+        os.mkdir(os.path.join(self.input_path, "subdir"))  # to make sure the tag is encountered *after* file1
+        os.link(
+            os.path.join(self.input_path, "file1"), os.path.join(self.input_path, "subdir", CACHE_TAG_NAME)
+        )  # correct tag name, hardlink to file1
+        self.cmd(f"--repo={self.repository_location}", "create", "test", "input")
         # in the "test" archive, we now have, in this order:
         # - a regular file item for "file1"
         # - a hardlink item for "CACHEDIR.TAG" referring back to file1 for its contents
-        self.cmd(f'--repo={self.repository_location}', 'recreate', 'test', '--exclude-caches', '--keep-exclude-tags')
+        self.cmd(f"--repo={self.repository_location}", "recreate", "test", "--exclude-caches", "--keep-exclude-tags")
         # if issue #4911 is present, the recreate will crash with a KeyError for "input/file1"
 
-    @pytest.mark.skipif(not xattr.XATTR_FAKEROOT, reason='Linux capabilities test, requires fakeroot >= 1.20.2')
+    @pytest.mark.skipif(not xattr.XATTR_FAKEROOT, reason="Linux capabilities test, requires fakeroot >= 1.20.2")
     def test_extract_capabilities(self):
         fchown = os.fchown
 
         # We need to manually patch chown to get the behaviour Linux has, since fakeroot does not
         # accurately model the interaction of chown(2) and Linux capabilities, i.e. it does not remove them.
         def patched_fchown(fd, uid, gid):
-            xattr.setxattr(fd, b'security.capability', b'', follow_symlinks=False)
+            xattr.setxattr(fd, b"security.capability", b"", follow_symlinks=False)
             fchown(fd, uid, gid)
 
         # The capability descriptor used here is valid and taken from a /usr/bin/ping
-        capabilities = b'\x01\x00\x00\x02\x00 \x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
-        self.create_regular_file('file')
-        xattr.setxattr(b'input/file', b'security.capability', capabilities)
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
-        self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
-        with changedir('output'):
-            with patch.object(os, 'fchown', patched_fchown):
-                self.cmd(f'--repo={self.repository_location}', 'extract', 'test')
-            assert xattr.getxattr(b'input/file', b'security.capability') == capabilities
+        capabilities = b"\x01\x00\x00\x02\x00 \x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+        self.create_regular_file("file")
+        xattr.setxattr(b"input/file", b"security.capability", capabilities)
+        self.cmd(f"--repo={self.repository_location}", "rcreate", RK_ENCRYPTION)
+        self.cmd(f"--repo={self.repository_location}", "create", "test", "input")
+        with changedir("output"):
+            with patch.object(os, "fchown", patched_fchown):
+                self.cmd(f"--repo={self.repository_location}", "extract", "test")
+            assert xattr.getxattr(b"input/file", b"security.capability") == capabilities
 
-    @pytest.mark.skipif(not xattr.XATTR_FAKEROOT, reason='xattr not supported on this system or on this version of'
-                                                         'fakeroot')
+    @pytest.mark.skipif(
+        not xattr.XATTR_FAKEROOT, reason="xattr not supported on this system or on this version of" "fakeroot"
+    )
     def test_extract_xattrs_errors(self):
         def patched_setxattr_E2BIG(*args, **kwargs):
-            raise OSError(errno.E2BIG, 'E2BIG')
+            raise OSError(errno.E2BIG, "E2BIG")
 
         def patched_setxattr_ENOTSUP(*args, **kwargs):
-            raise OSError(errno.ENOTSUP, 'ENOTSUP')
+            raise OSError(errno.ENOTSUP, "ENOTSUP")
 
         def patched_setxattr_EACCES(*args, **kwargs):
-            raise OSError(errno.EACCES, 'EACCES')
+            raise OSError(errno.EACCES, "EACCES")
 
-        self.create_regular_file('file')
-        xattr.setxattr(b'input/file', b'user.attribute', b'value')
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', '-e' 'none')
-        self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
-        with changedir('output'):
-            input_abspath = os.path.abspath('input/file')
-            with patch.object(xattr, 'setxattr', patched_setxattr_E2BIG):
-                out = self.cmd(f'--repo={self.repository_location}', 'extract', 'test', exit_code=EXIT_WARNING)
-                assert ': when setting extended attribute user.attribute: too big for this filesystem\n' in out
+        self.create_regular_file("file")
+        xattr.setxattr(b"input/file", b"user.attribute", b"value")
+        self.cmd(f"--repo={self.repository_location}", "rcreate", "-e" "none")
+        self.cmd(f"--repo={self.repository_location}", "create", "test", "input")
+        with changedir("output"):
+            input_abspath = os.path.abspath("input/file")
+            with patch.object(xattr, "setxattr", patched_setxattr_E2BIG):
+                out = self.cmd(f"--repo={self.repository_location}", "extract", "test", exit_code=EXIT_WARNING)
+                assert ": when setting extended attribute user.attribute: too big for this filesystem\n" in out
             os.remove(input_abspath)
-            with patch.object(xattr, 'setxattr', patched_setxattr_ENOTSUP):
-                out = self.cmd(f'--repo={self.repository_location}', 'extract', 'test', exit_code=EXIT_WARNING)
-                assert ': when setting extended attribute user.attribute: xattrs not supported on this filesystem\n' in out
+            with patch.object(xattr, "setxattr", patched_setxattr_ENOTSUP):
+                out = self.cmd(f"--repo={self.repository_location}", "extract", "test", exit_code=EXIT_WARNING)
+                assert (
+                    ": when setting extended attribute user.attribute: xattrs not supported on this filesystem\n" in out
+                )
             os.remove(input_abspath)
-            with patch.object(xattr, 'setxattr', patched_setxattr_EACCES):
-                out = self.cmd(f'--repo={self.repository_location}', 'extract', 'test', exit_code=EXIT_WARNING)
-                assert ': when setting extended attribute user.attribute: Permission denied\n' in out
+            with patch.object(xattr, "setxattr", patched_setxattr_EACCES):
+                out = self.cmd(f"--repo={self.repository_location}", "extract", "test", exit_code=EXIT_WARNING)
+                assert ": when setting extended attribute user.attribute: Permission denied\n" in out
             assert os.path.isfile(input_abspath)
 
     def test_path_normalization(self):
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
-        self.create_regular_file('dir1/dir2/file', size=1024 * 80)
-        with changedir('input/dir1/dir2'):
-            self.cmd(f'--repo={self.repository_location}', 'create', 'test',
-                     '../../../input/dir1/../dir1/dir2/..')
-        output = self.cmd(f'--repo={self.repository_location}', 'list', 'test')
-        self.assert_not_in('..', output)
-        self.assert_in(' input/dir1/dir2/file', output)
+        self.cmd(f"--repo={self.repository_location}", "rcreate", RK_ENCRYPTION)
+        self.create_regular_file("dir1/dir2/file", size=1024 * 80)
+        with changedir("input/dir1/dir2"):
+            self.cmd(f"--repo={self.repository_location}", "create", "test", "../../../input/dir1/../dir1/dir2/..")
+        output = self.cmd(f"--repo={self.repository_location}", "list", "test")
+        self.assert_not_in("..", output)
+        self.assert_in(" input/dir1/dir2/file", output)
 
     def test_exclude_normalization(self):
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
-        self.create_regular_file('file1', size=1024 * 80)
-        self.create_regular_file('file2', size=1024 * 80)
-        with changedir('input'):
-            self.cmd(f'--repo={self.repository_location}', 'create', 'test1', '.', '--exclude=file1')
-        with changedir('output'):
-            self.cmd(f'--repo={self.repository_location}', 'extract', 'test1')
-        self.assert_equal(sorted(os.listdir('output')), ['file2'])
-        with changedir('input'):
-            self.cmd(f'--repo={self.repository_location}', 'create', 'test2', '.', '--exclude=./file1')
-        with changedir('output'):
-            self.cmd(f'--repo={self.repository_location}', 'extract', 'test2')
-        self.assert_equal(sorted(os.listdir('output')), ['file2'])
-        self.cmd(f'--repo={self.repository_location}', 'create', 'test3', 'input', '--exclude=input/./file1')
-        with changedir('output'):
-            self.cmd(f'--repo={self.repository_location}', 'extract', 'test3')
-        self.assert_equal(sorted(os.listdir('output/input')), ['file2'])
+        self.cmd(f"--repo={self.repository_location}", "rcreate", RK_ENCRYPTION)
+        self.create_regular_file("file1", size=1024 * 80)
+        self.create_regular_file("file2", size=1024 * 80)
+        with changedir("input"):
+            self.cmd(f"--repo={self.repository_location}", "create", "test1", ".", "--exclude=file1")
+        with changedir("output"):
+            self.cmd(f"--repo={self.repository_location}", "extract", "test1")
+        self.assert_equal(sorted(os.listdir("output")), ["file2"])
+        with changedir("input"):
+            self.cmd(f"--repo={self.repository_location}", "create", "test2", ".", "--exclude=./file1")
+        with changedir("output"):
+            self.cmd(f"--repo={self.repository_location}", "extract", "test2")
+        self.assert_equal(sorted(os.listdir("output")), ["file2"])
+        self.cmd(f"--repo={self.repository_location}", "create", "test3", "input", "--exclude=input/./file1")
+        with changedir("output"):
+            self.cmd(f"--repo={self.repository_location}", "extract", "test3")
+        self.assert_equal(sorted(os.listdir("output/input")), ["file2"])
 
     def test_repeated_files(self):
-        self.create_regular_file('file1', size=1024 * 80)
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
-        self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input', 'input')
+        self.create_regular_file("file1", size=1024 * 80)
+        self.cmd(f"--repo={self.repository_location}", "rcreate", RK_ENCRYPTION)
+        self.cmd(f"--repo={self.repository_location}", "create", "test", "input", "input")
 
     def test_overwrite(self):
-        self.create_regular_file('file1', size=1024 * 80)
-        self.create_regular_file('dir2/file2', size=1024 * 80)
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
-        self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
+        self.create_regular_file("file1", size=1024 * 80)
+        self.create_regular_file("dir2/file2", size=1024 * 80)
+        self.cmd(f"--repo={self.repository_location}", "rcreate", RK_ENCRYPTION)
+        self.cmd(f"--repo={self.repository_location}", "create", "test", "input")
         # Overwriting regular files and directories should be supported
-        os.mkdir('output/input')
-        os.mkdir('output/input/file1')
-        os.mkdir('output/input/dir2')
-        with changedir('output'):
-            self.cmd(f'--repo={self.repository_location}', 'extract', 'test')
-        self.assert_dirs_equal('input', 'output/input')
+        os.mkdir("output/input")
+        os.mkdir("output/input/file1")
+        os.mkdir("output/input/dir2")
+        with changedir("output"):
+            self.cmd(f"--repo={self.repository_location}", "extract", "test")
+        self.assert_dirs_equal("input", "output/input")
         # But non-empty dirs should fail
-        os.unlink('output/input/file1')
-        os.mkdir('output/input/file1')
-        os.mkdir('output/input/file1/dir')
-        with changedir('output'):
-            self.cmd(f'--repo={self.repository_location}', 'extract', 'test', exit_code=1)
+        os.unlink("output/input/file1")
+        os.mkdir("output/input/file1")
+        os.mkdir("output/input/file1/dir")
+        with changedir("output"):
+            self.cmd(f"--repo={self.repository_location}", "extract", "test", exit_code=1)
 
     def test_rename(self):
-        self.create_regular_file('file1', size=1024 * 80)
-        self.create_regular_file('dir2/file2', size=1024 * 80)
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
-        self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
-        self.cmd(f'--repo={self.repository_location}', 'create', 'test.2', 'input')
-        self.cmd(f'--repo={self.repository_location}', 'extract', 'test', '--dry-run')
-        self.cmd(f'--repo={self.repository_location}', 'extract', 'test.2', '--dry-run')
-        self.cmd(f'--repo={self.repository_location}', 'rename', 'test', 'test.3')
-        self.cmd(f'--repo={self.repository_location}', 'extract', 'test.2', '--dry-run')
-        self.cmd(f'--repo={self.repository_location}', 'rename', 'test.2', 'test.4')
-        self.cmd(f'--repo={self.repository_location}', 'extract', 'test.3', '--dry-run')
-        self.cmd(f'--repo={self.repository_location}', 'extract', 'test.4', '--dry-run')
+        self.create_regular_file("file1", size=1024 * 80)
+        self.create_regular_file("dir2/file2", size=1024 * 80)
+        self.cmd(f"--repo={self.repository_location}", "rcreate", RK_ENCRYPTION)
+        self.cmd(f"--repo={self.repository_location}", "create", "test", "input")
+        self.cmd(f"--repo={self.repository_location}", "create", "test.2", "input")
+        self.cmd(f"--repo={self.repository_location}", "extract", "test", "--dry-run")
+        self.cmd(f"--repo={self.repository_location}", "extract", "test.2", "--dry-run")
+        self.cmd(f"--repo={self.repository_location}", "rename", "test", "test.3")
+        self.cmd(f"--repo={self.repository_location}", "extract", "test.2", "--dry-run")
+        self.cmd(f"--repo={self.repository_location}", "rename", "test.2", "test.4")
+        self.cmd(f"--repo={self.repository_location}", "extract", "test.3", "--dry-run")
+        self.cmd(f"--repo={self.repository_location}", "extract", "test.4", "--dry-run")
         # Make sure both archives have been renamed
         with Repository(self.repository_path) as repository:
             manifest, key = Manifest.load(repository, Manifest.NO_OPERATION_CHECK)
         self.assert_equal(len(manifest.archives), 2)
-        self.assert_in('test.3', manifest.archives)
-        self.assert_in('test.4', manifest.archives)
+        self.assert_in("test.3", manifest.archives)
+        self.assert_in("test.4", manifest.archives)
 
     def test_info(self):
-        self.create_regular_file('file1', size=1024 * 80)
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
-        self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
-        info_repo = self.cmd(f'--repo={self.repository_location}', 'rinfo')
-        assert 'Original size:' in info_repo
-        info_archive = self.cmd(f'--repo={self.repository_location}', 'info', '-a', 'test')
-        assert 'Archive name: test\n' in info_archive
-        info_archive = self.cmd(f'--repo={self.repository_location}', 'info', '--first', '1')
-        assert 'Archive name: test\n' in info_archive
+        self.create_regular_file("file1", size=1024 * 80)
+        self.cmd(f"--repo={self.repository_location}", "rcreate", RK_ENCRYPTION)
+        self.cmd(f"--repo={self.repository_location}", "create", "test", "input")
+        info_repo = self.cmd(f"--repo={self.repository_location}", "rinfo")
+        assert "Original size:" in info_repo
+        info_archive = self.cmd(f"--repo={self.repository_location}", "info", "-a", "test")
+        assert "Archive name: test\n" in info_archive
+        info_archive = self.cmd(f"--repo={self.repository_location}", "info", "--first", "1")
+        assert "Archive name: test\n" in info_archive
 
     def test_info_json(self):
-        self.create_regular_file('file1', size=1024 * 80)
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
-        self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
-        info_repo = json.loads(self.cmd(f'--repo={self.repository_location}', 'rinfo', '--json'))
-        repository = info_repo['repository']
-        assert len(repository['id']) == 64
-        assert 'last_modified' in repository
-        assert datetime.strptime(repository['last_modified'], ISO_FORMAT)  # must not raise
-        assert info_repo['encryption']['mode'] == RK_ENCRYPTION[13:]
-        assert 'keyfile' not in info_repo['encryption']
-        cache = info_repo['cache']
-        stats = cache['stats']
+        self.create_regular_file("file1", size=1024 * 80)
+        self.cmd(f"--repo={self.repository_location}", "rcreate", RK_ENCRYPTION)
+        self.cmd(f"--repo={self.repository_location}", "create", "test", "input")
+        info_repo = json.loads(self.cmd(f"--repo={self.repository_location}", "rinfo", "--json"))
+        repository = info_repo["repository"]
+        assert len(repository["id"]) == 64
+        assert "last_modified" in repository
+        assert datetime.strptime(repository["last_modified"], ISO_FORMAT)  # must not raise
+        assert info_repo["encryption"]["mode"] == RK_ENCRYPTION[13:]
+        assert "keyfile" not in info_repo["encryption"]
+        cache = info_repo["cache"]
+        stats = cache["stats"]
         assert all(isinstance(o, int) for o in stats.values())
-        assert all(key in stats for key in ('total_chunks', 'total_size', 'total_unique_chunks', 'unique_size'))
+        assert all(key in stats for key in ("total_chunks", "total_size", "total_unique_chunks", "unique_size"))
 
-        info_archive = json.loads(self.cmd(f'--repo={self.repository_location}', 'info', '-a', 'test', '--json'))
-        assert info_repo['repository'] == info_archive['repository']
-        assert info_repo['cache'] == info_archive['cache']
-        archives = info_archive['archives']
+        info_archive = json.loads(self.cmd(f"--repo={self.repository_location}", "info", "-a", "test", "--json"))
+        assert info_repo["repository"] == info_archive["repository"]
+        assert info_repo["cache"] == info_archive["cache"]
+        archives = info_archive["archives"]
         assert len(archives) == 1
         archive = archives[0]
-        assert archive['name'] == 'test'
-        assert isinstance(archive['command_line'], list)
-        assert isinstance(archive['duration'], float)
-        assert len(archive['id']) == 64
-        assert 'stats' in archive
-        assert datetime.strptime(archive['start'], ISO_FORMAT)
-        assert datetime.strptime(archive['end'], ISO_FORMAT)
+        assert archive["name"] == "test"
+        assert isinstance(archive["command_line"], list)
+        assert isinstance(archive["duration"], float)
+        assert len(archive["id"]) == 64
+        assert "stats" in archive
+        assert datetime.strptime(archive["start"], ISO_FORMAT)
+        assert datetime.strptime(archive["end"], ISO_FORMAT)
 
     def test_info_json_of_empty_archive(self):
         """See https://github.com/borgbackup/borg/issues/6120"""
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
-        info_repo = json.loads(self.cmd(f'--repo={self.repository_location}', 'info', '--json', '--first=1'))
+        self.cmd(f"--repo={self.repository_location}", "rcreate", RK_ENCRYPTION)
+        info_repo = json.loads(self.cmd(f"--repo={self.repository_location}", "info", "--json", "--first=1"))
         assert info_repo["archives"] == []
-        info_repo = json.loads(self.cmd(f'--repo={self.repository_location}', 'info', '--json', '--last=1'))
+        info_repo = json.loads(self.cmd(f"--repo={self.repository_location}", "info", "--json", "--last=1"))
         assert info_repo["archives"] == []
 
     def test_comment(self):
-        self.create_regular_file('file1', size=1024 * 80)
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
-        self.cmd(f'--repo={self.repository_location}', 'create', 'test1', 'input')
-        self.cmd(f'--repo={self.repository_location}', 'create', 'test2', 'input', '--comment', 'this is the comment')
-        self.cmd(f'--repo={self.repository_location}', 'create', 'test3', 'input', '--comment', '"deleted" comment')
-        self.cmd(f'--repo={self.repository_location}', 'create', 'test4', 'input', '--comment', 'preserved comment')
-        assert 'Comment: \n' in self.cmd(f'--repo={self.repository_location}', 'info', '-a', 'test1')
-        assert 'Comment: this is the comment' in self.cmd(f'--repo={self.repository_location}', 'info', '-a', 'test2')
+        self.create_regular_file("file1", size=1024 * 80)
+        self.cmd(f"--repo={self.repository_location}", "rcreate", RK_ENCRYPTION)
+        self.cmd(f"--repo={self.repository_location}", "create", "test1", "input")
+        self.cmd(f"--repo={self.repository_location}", "create", "test2", "input", "--comment", "this is the comment")
+        self.cmd(f"--repo={self.repository_location}", "create", "test3", "input", "--comment", '"deleted" comment')
+        self.cmd(f"--repo={self.repository_location}", "create", "test4", "input", "--comment", "preserved comment")
+        assert "Comment: \n" in self.cmd(f"--repo={self.repository_location}", "info", "-a", "test1")
+        assert "Comment: this is the comment" in self.cmd(f"--repo={self.repository_location}", "info", "-a", "test2")
 
-        self.cmd(f'--repo={self.repository_location}', 'recreate', '-a', 'test1', '--comment', 'added comment')
-        self.cmd(f'--repo={self.repository_location}', 'recreate', '-a', 'test2', '--comment', 'modified comment')
-        self.cmd(f'--repo={self.repository_location}', 'recreate', '-a', 'test3', '--comment', '')
-        self.cmd(f'--repo={self.repository_location}', 'recreate', '-a', 'test4', '12345')
-        assert 'Comment: added comment' in self.cmd(f'--repo={self.repository_location}', 'info', '-a', 'test1')
-        assert 'Comment: modified comment' in self.cmd(f'--repo={self.repository_location}', 'info', '-a', 'test2')
-        assert 'Comment: \n' in self.cmd(f'--repo={self.repository_location}', 'info', '-a', 'test3')
-        assert 'Comment: preserved comment' in self.cmd(f'--repo={self.repository_location}', 'info', '-a', 'test4')
+        self.cmd(f"--repo={self.repository_location}", "recreate", "-a", "test1", "--comment", "added comment")
+        self.cmd(f"--repo={self.repository_location}", "recreate", "-a", "test2", "--comment", "modified comment")
+        self.cmd(f"--repo={self.repository_location}", "recreate", "-a", "test3", "--comment", "")
+        self.cmd(f"--repo={self.repository_location}", "recreate", "-a", "test4", "12345")
+        assert "Comment: added comment" in self.cmd(f"--repo={self.repository_location}", "info", "-a", "test1")
+        assert "Comment: modified comment" in self.cmd(f"--repo={self.repository_location}", "info", "-a", "test2")
+        assert "Comment: \n" in self.cmd(f"--repo={self.repository_location}", "info", "-a", "test3")
+        assert "Comment: preserved comment" in self.cmd(f"--repo={self.repository_location}", "info", "-a", "test4")
 
     def test_delete(self):
-        self.create_regular_file('file1', size=1024 * 80)
-        self.create_regular_file('dir2/file2', size=1024 * 80)
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
-        self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
-        self.cmd(f'--repo={self.repository_location}', 'create', 'test.2', 'input')
-        self.cmd(f'--repo={self.repository_location}', 'create', 'test.3', 'input')
-        self.cmd(f'--repo={self.repository_location}', 'create', 'another_test.1', 'input')
-        self.cmd(f'--repo={self.repository_location}', 'create', 'another_test.2', 'input')
-        self.cmd(f'--repo={self.repository_location}', 'extract', 'test', '--dry-run')
-        self.cmd(f'--repo={self.repository_location}', 'extract', 'test.2', '--dry-run')
-        self.cmd(f'--repo={self.repository_location}', 'delete', '--glob-archives', 'another_*')
-        self.cmd(f'--repo={self.repository_location}', 'delete', '--last', '1')
-        self.cmd(f'--repo={self.repository_location}', 'delete', '-a', 'test')
-        self.cmd(f'--repo={self.repository_location}', 'extract', 'test.2', '--dry-run')
-        output = self.cmd(f'--repo={self.repository_location}', 'delete', '-a', 'test.2', '--stats')
-        self.assert_in('Original size: -', output)  # negative size == deleted data
+        self.create_regular_file("file1", size=1024 * 80)
+        self.create_regular_file("dir2/file2", size=1024 * 80)
+        self.cmd(f"--repo={self.repository_location}", "rcreate", RK_ENCRYPTION)
+        self.cmd(f"--repo={self.repository_location}", "create", "test", "input")
+        self.cmd(f"--repo={self.repository_location}", "create", "test.2", "input")
+        self.cmd(f"--repo={self.repository_location}", "create", "test.3", "input")
+        self.cmd(f"--repo={self.repository_location}", "create", "another_test.1", "input")
+        self.cmd(f"--repo={self.repository_location}", "create", "another_test.2", "input")
+        self.cmd(f"--repo={self.repository_location}", "extract", "test", "--dry-run")
+        self.cmd(f"--repo={self.repository_location}", "extract", "test.2", "--dry-run")
+        self.cmd(f"--repo={self.repository_location}", "delete", "--glob-archives", "another_*")
+        self.cmd(f"--repo={self.repository_location}", "delete", "--last", "1")
+        self.cmd(f"--repo={self.repository_location}", "delete", "-a", "test")
+        self.cmd(f"--repo={self.repository_location}", "extract", "test.2", "--dry-run")
+        output = self.cmd(f"--repo={self.repository_location}", "delete", "-a", "test.2", "--stats")
+        self.assert_in("Original size: -", output)  # negative size == deleted data
         # Make sure all data except the manifest has been deleted
         with Repository(self.repository_path) as repository:
             self.assert_equal(len(repository), 1)
 
     def test_delete_multiple(self):
-        self.create_regular_file('file1', size=1024 * 80)
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
-        self.cmd(f'--repo={self.repository_location}', 'create', 'test1', 'input')
-        self.cmd(f'--repo={self.repository_location}', 'create', 'test2', 'input')
-        self.cmd(f'--repo={self.repository_location}', 'create', 'test3', 'input')
-        self.cmd(f'--repo={self.repository_location}', 'delete', '-a', 'test1')
-        self.cmd(f'--repo={self.repository_location}', 'delete', '-a', 'test2')
-        self.cmd(f'--repo={self.repository_location}', 'extract', 'test3', '--dry-run')
-        self.cmd(f'--repo={self.repository_location}', 'delete', '-a', 'test3')
-        assert not self.cmd(f'--repo={self.repository_location}', 'rlist')
+        self.create_regular_file("file1", size=1024 * 80)
+        self.cmd(f"--repo={self.repository_location}", "rcreate", RK_ENCRYPTION)
+        self.cmd(f"--repo={self.repository_location}", "create", "test1", "input")
+        self.cmd(f"--repo={self.repository_location}", "create", "test2", "input")
+        self.cmd(f"--repo={self.repository_location}", "create", "test3", "input")
+        self.cmd(f"--repo={self.repository_location}", "delete", "-a", "test1")
+        self.cmd(f"--repo={self.repository_location}", "delete", "-a", "test2")
+        self.cmd(f"--repo={self.repository_location}", "extract", "test3", "--dry-run")
+        self.cmd(f"--repo={self.repository_location}", "delete", "-a", "test3")
+        assert not self.cmd(f"--repo={self.repository_location}", "rlist")
 
     def test_delete_repo(self):
-        self.create_regular_file('file1', size=1024 * 80)
-        self.create_regular_file('dir2/file2', size=1024 * 80)
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
-        self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
-        self.cmd(f'--repo={self.repository_location}', 'create', 'test.2', 'input')
-        os.environ['BORG_DELETE_I_KNOW_WHAT_I_AM_DOING'] = 'no'
-        self.cmd(f'--repo={self.repository_location}', 'rdelete', exit_code=2)
+        self.create_regular_file("file1", size=1024 * 80)
+        self.create_regular_file("dir2/file2", size=1024 * 80)
+        self.cmd(f"--repo={self.repository_location}", "rcreate", RK_ENCRYPTION)
+        self.cmd(f"--repo={self.repository_location}", "create", "test", "input")
+        self.cmd(f"--repo={self.repository_location}", "create", "test.2", "input")
+        os.environ["BORG_DELETE_I_KNOW_WHAT_I_AM_DOING"] = "no"
+        self.cmd(f"--repo={self.repository_location}", "rdelete", exit_code=2)
         assert os.path.exists(self.repository_path)
-        os.environ['BORG_DELETE_I_KNOW_WHAT_I_AM_DOING'] = 'YES'
-        self.cmd(f'--repo={self.repository_location}', 'rdelete')
+        os.environ["BORG_DELETE_I_KNOW_WHAT_I_AM_DOING"] = "YES"
+        self.cmd(f"--repo={self.repository_location}", "rdelete")
         # Make sure the repo is gone
         self.assertFalse(os.path.exists(self.repository_path))
 
     def test_delete_force(self):
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=none')
-        self.create_src_archive('test')
+        self.cmd(f"--repo={self.repository_location}", "rcreate", "--encryption=none")
+        self.create_src_archive("test")
         with Repository(self.repository_path, exclusive=True) as repository:
             manifest, key = Manifest.load(repository, Manifest.NO_OPERATION_CHECK)
-            archive = Archive(repository, key, manifest, 'test')
+            archive = Archive(repository, key, manifest, "test")
             for item in archive.iter_items():
-                if item.path.endswith('testsuite/archiver.py'):
+                if item.path.endswith("testsuite/archiver.py"):
                     repository.delete(item.chunks[-1].id)
                     break
             else:
                 assert False  # missed the file
             repository.commit(compact=False)
-        output = self.cmd(f'--repo={self.repository_location}', 'delete', '-a', 'test', '--force')
-        self.assert_in('deleted archive was corrupted', output)
-        self.cmd(f'--repo={self.repository_location}', 'check', '--repair')
-        output = self.cmd(f'--repo={self.repository_location}', 'rlist')
-        self.assert_not_in('test', output)
+        output = self.cmd(f"--repo={self.repository_location}", "delete", "-a", "test", "--force")
+        self.assert_in("deleted archive was corrupted", output)
+        self.cmd(f"--repo={self.repository_location}", "check", "--repair")
+        output = self.cmd(f"--repo={self.repository_location}", "rlist")
+        self.assert_not_in("test", output)
 
     def test_delete_double_force(self):
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=none')
-        self.create_src_archive('test')
+        self.cmd(f"--repo={self.repository_location}", "rcreate", "--encryption=none")
+        self.create_src_archive("test")
         with Repository(self.repository_path, exclusive=True) as repository:
             manifest, key = Manifest.load(repository, Manifest.NO_OPERATION_CHECK)
-            archive = Archive(repository, key, manifest, 'test')
+            archive = Archive(repository, key, manifest, "test")
             id = archive.metadata.items[0]
-            repository.put(id, b'corrupted items metadata stream chunk')
+            repository.put(id, b"corrupted items metadata stream chunk")
             repository.commit(compact=False)
-        self.cmd(f'--repo={self.repository_location}', 'delete', '-a', 'test', '--force', '--force')
-        self.cmd(f'--repo={self.repository_location}', 'check', '--repair')
-        output = self.cmd(f'--repo={self.repository_location}', 'rlist')
-        self.assert_not_in('test', output)
+        self.cmd(f"--repo={self.repository_location}", "delete", "-a", "test", "--force", "--force")
+        self.cmd(f"--repo={self.repository_location}", "check", "--repair")
+        output = self.cmd(f"--repo={self.repository_location}", "rlist")
+        self.assert_not_in("test", output)
 
     def test_corrupted_repository(self):
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
-        self.create_src_archive('test')
-        self.cmd(f'--repo={self.repository_location}', 'extract', 'test', '--dry-run')
-        output = self.cmd(f'--repo={self.repository_location}', 'check', '--show-version')
-        self.assert_in('borgbackup version', output)  # implied output even without --info given
-        self.assert_not_in('Starting repository check', output)  # --info not given for root logger
+        self.cmd(f"--repo={self.repository_location}", "rcreate", RK_ENCRYPTION)
+        self.create_src_archive("test")
+        self.cmd(f"--repo={self.repository_location}", "extract", "test", "--dry-run")
+        output = self.cmd(f"--repo={self.repository_location}", "check", "--show-version")
+        self.assert_in("borgbackup version", output)  # implied output even without --info given
+        self.assert_not_in("Starting repository check", output)  # --info not given for root logger
 
-        name = sorted(os.listdir(os.path.join(self.tmpdir, 'repository', 'data', '0')), reverse=True)[1]
-        with open(os.path.join(self.tmpdir, 'repository', 'data', '0', name), 'r+b') as fd:
+        name = sorted(os.listdir(os.path.join(self.tmpdir, "repository", "data", "0")), reverse=True)[1]
+        with open(os.path.join(self.tmpdir, "repository", "data", "0", name), "r+b") as fd:
             fd.seek(100)
-            fd.write(b'XXXX')
-        output = self.cmd(f'--repo={self.repository_location}', 'check', '--info', exit_code=1)
-        self.assert_in('Starting repository check', output)  # --info given for root logger
+            fd.write(b"XXXX")
+        output = self.cmd(f"--repo={self.repository_location}", "check", "--info", exit_code=1)
+        self.assert_in("Starting repository check", output)  # --info given for root logger
 
     def test_readonly_check(self):
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
-        self.create_src_archive('test')
+        self.cmd(f"--repo={self.repository_location}", "rcreate", RK_ENCRYPTION)
+        self.create_src_archive("test")
         with self.read_only(self.repository_path):
             # verify that command normally doesn't work with read-only repo
             if self.FORK_DEFAULT:
-                self.cmd(f'--repo={self.repository_location}', 'check', '--verify-data', exit_code=EXIT_ERROR)
+                self.cmd(f"--repo={self.repository_location}", "check", "--verify-data", exit_code=EXIT_ERROR)
             else:
                 with pytest.raises((LockFailed, RemoteRepository.RPCError)) as excinfo:
-                    self.cmd(f'--repo={self.repository_location}', 'check', '--verify-data')
+                    self.cmd(f"--repo={self.repository_location}", "check", "--verify-data")
                 if isinstance(excinfo.value, RemoteRepository.RPCError):
-                    assert excinfo.value.exception_class == 'LockFailed'
+                    assert excinfo.value.exception_class == "LockFailed"
             # verify that command works with read-only repo when using --bypass-lock
-            self.cmd(f'--repo={self.repository_location}', 'check', '--verify-data', '--bypass-lock')
+            self.cmd(f"--repo={self.repository_location}", "check", "--verify-data", "--bypass-lock")
 
     def test_readonly_diff(self):
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
-        self.create_src_archive('a')
-        self.create_src_archive('b')
+        self.cmd(f"--repo={self.repository_location}", "rcreate", RK_ENCRYPTION)
+        self.create_src_archive("a")
+        self.create_src_archive("b")
         with self.read_only(self.repository_path):
             # verify that command normally doesn't work with read-only repo
             if self.FORK_DEFAULT:
-                self.cmd(f'--repo={self.repository_location}', 'diff', 'a', 'b', exit_code=EXIT_ERROR)
+                self.cmd(f"--repo={self.repository_location}", "diff", "a", "b", exit_code=EXIT_ERROR)
             else:
                 with pytest.raises((LockFailed, RemoteRepository.RPCError)) as excinfo:
-                    self.cmd(f'--repo={self.repository_location}', 'diff', 'a', 'b')
+                    self.cmd(f"--repo={self.repository_location}", "diff", "a", "b")
                 if isinstance(excinfo.value, RemoteRepository.RPCError):
-                    assert excinfo.value.exception_class == 'LockFailed'
+                    assert excinfo.value.exception_class == "LockFailed"
             # verify that command works with read-only repo when using --bypass-lock
-            self.cmd(f'--repo={self.repository_location}', 'diff', 'a', 'b', '--bypass-lock')
+            self.cmd(f"--repo={self.repository_location}", "diff", "a", "b", "--bypass-lock")
 
     def test_readonly_export_tar(self):
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
-        self.create_src_archive('test')
+        self.cmd(f"--repo={self.repository_location}", "rcreate", RK_ENCRYPTION)
+        self.create_src_archive("test")
         with self.read_only(self.repository_path):
             # verify that command normally doesn't work with read-only repo
             if self.FORK_DEFAULT:
-                self.cmd(f'--repo={self.repository_location}', 'export-tar', 'test', 'test.tar', exit_code=EXIT_ERROR)
+                self.cmd(f"--repo={self.repository_location}", "export-tar", "test", "test.tar", exit_code=EXIT_ERROR)
             else:
                 with pytest.raises((LockFailed, RemoteRepository.RPCError)) as excinfo:
-                    self.cmd(f'--repo={self.repository_location}', 'export-tar', 'test', 'test.tar')
+                    self.cmd(f"--repo={self.repository_location}", "export-tar", "test", "test.tar")
                 if isinstance(excinfo.value, RemoteRepository.RPCError):
-                    assert excinfo.value.exception_class == 'LockFailed'
+                    assert excinfo.value.exception_class == "LockFailed"
             # verify that command works with read-only repo when using --bypass-lock
-            self.cmd(f'--repo={self.repository_location}', 'export-tar', 'test', 'test.tar', '--bypass-lock')
+            self.cmd(f"--repo={self.repository_location}", "export-tar", "test", "test.tar", "--bypass-lock")
 
     def test_readonly_extract(self):
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
-        self.create_src_archive('test')
+        self.cmd(f"--repo={self.repository_location}", "rcreate", RK_ENCRYPTION)
+        self.create_src_archive("test")
         with self.read_only(self.repository_path):
             # verify that command normally doesn't work with read-only repo
             if self.FORK_DEFAULT:
-                self.cmd(f'--repo={self.repository_location}', 'extract', 'test', exit_code=EXIT_ERROR)
+                self.cmd(f"--repo={self.repository_location}", "extract", "test", exit_code=EXIT_ERROR)
             else:
                 with pytest.raises((LockFailed, RemoteRepository.RPCError)) as excinfo:
-                    self.cmd(f'--repo={self.repository_location}', 'extract', 'test')
+                    self.cmd(f"--repo={self.repository_location}", "extract", "test")
                 if isinstance(excinfo.value, RemoteRepository.RPCError):
-                    assert excinfo.value.exception_class == 'LockFailed'
+                    assert excinfo.value.exception_class == "LockFailed"
             # verify that command works with read-only repo when using --bypass-lock
-            self.cmd(f'--repo={self.repository_location}', 'extract', 'test', '--bypass-lock')
+            self.cmd(f"--repo={self.repository_location}", "extract", "test", "--bypass-lock")
 
     def test_readonly_info(self):
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
-        self.create_src_archive('test')
+        self.cmd(f"--repo={self.repository_location}", "rcreate", RK_ENCRYPTION)
+        self.create_src_archive("test")
         with self.read_only(self.repository_path):
             # verify that command normally doesn't work with read-only repo
             if self.FORK_DEFAULT:
-                self.cmd(f'--repo={self.repository_location}', 'rinfo', exit_code=EXIT_ERROR)
+                self.cmd(f"--repo={self.repository_location}", "rinfo", exit_code=EXIT_ERROR)
             else:
                 with pytest.raises((LockFailed, RemoteRepository.RPCError)) as excinfo:
-                    self.cmd(f'--repo={self.repository_location}', 'rinfo')
+                    self.cmd(f"--repo={self.repository_location}", "rinfo")
                 if isinstance(excinfo.value, RemoteRepository.RPCError):
-                    assert excinfo.value.exception_class == 'LockFailed'
+                    assert excinfo.value.exception_class == "LockFailed"
             # verify that command works with read-only repo when using --bypass-lock
-            self.cmd(f'--repo={self.repository_location}', 'rinfo', '--bypass-lock')
+            self.cmd(f"--repo={self.repository_location}", "rinfo", "--bypass-lock")
 
     def test_readonly_list(self):
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
-        self.create_src_archive('test')
+        self.cmd(f"--repo={self.repository_location}", "rcreate", RK_ENCRYPTION)
+        self.create_src_archive("test")
         with self.read_only(self.repository_path):
             # verify that command normally doesn't work with read-only repo
             if self.FORK_DEFAULT:
-                self.cmd(f'--repo={self.repository_location}', 'rlist', exit_code=EXIT_ERROR)
+                self.cmd(f"--repo={self.repository_location}", "rlist", exit_code=EXIT_ERROR)
             else:
                 with pytest.raises((LockFailed, RemoteRepository.RPCError)) as excinfo:
-                    self.cmd(f'--repo={self.repository_location}', 'rlist')
+                    self.cmd(f"--repo={self.repository_location}", "rlist")
                 if isinstance(excinfo.value, RemoteRepository.RPCError):
-                    assert excinfo.value.exception_class == 'LockFailed'
+                    assert excinfo.value.exception_class == "LockFailed"
             # verify that command works with read-only repo when using --bypass-lock
-            self.cmd(f'--repo={self.repository_location}', 'rlist', '--bypass-lock')
+            self.cmd(f"--repo={self.repository_location}", "rlist", "--bypass-lock")
 
-    @unittest.skipUnless(llfuse, 'llfuse not installed')
+    @unittest.skipUnless(llfuse, "llfuse not installed")
     def test_readonly_mount(self):
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
-        self.create_src_archive('test')
+        self.cmd(f"--repo={self.repository_location}", "rcreate", RK_ENCRYPTION)
+        self.create_src_archive("test")
         with self.read_only(self.repository_path):
             # verify that command normally doesn't work with read-only repo
             if self.FORK_DEFAULT:
@@ -1788,22 +1930,22 @@ class ArchiverTestCase(ArchiverTestCaseBase):
                     with self.fuse_mount(self.repository_location, fork=False):
                         pass
                 if isinstance(excinfo.value, RemoteRepository.RPCError):
-                    assert excinfo.value.exception_class == 'LockFailed'
+                    assert excinfo.value.exception_class == "LockFailed"
             # verify that command works with read-only repo when using --bypass-lock
-            with self.fuse_mount(self.repository_location, None, '--bypass-lock'):
+            with self.fuse_mount(self.repository_location, None, "--bypass-lock"):
                 pass
 
-    @pytest.mark.skipif('BORG_TESTS_IGNORE_MODES' in os.environ, reason='modes unreliable')
+    @pytest.mark.skipif("BORG_TESTS_IGNORE_MODES" in os.environ, reason="modes unreliable")
     def test_umask(self):
-        self.create_regular_file('file1', size=1024 * 80)
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
-        self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
+        self.create_regular_file("file1", size=1024 * 80)
+        self.cmd(f"--repo={self.repository_location}", "rcreate", RK_ENCRYPTION)
+        self.cmd(f"--repo={self.repository_location}", "create", "test", "input")
         mode = os.stat(self.repository_path).st_mode
         self.assertEqual(stat.S_IMODE(mode), 0o700)
 
     def test_create_dry_run(self):
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
-        self.cmd(f'--repo={self.repository_location}', 'create', '--dry-run', 'test', 'input')
+        self.cmd(f"--repo={self.repository_location}", "rcreate", RK_ENCRYPTION)
+        self.cmd(f"--repo={self.repository_location}", "create", "--dry-run", "test", "input")
         # Make sure no archive has been created
         with Repository(self.repository_path) as repository:
             manifest, key = Manifest.load(repository, Manifest.NO_OPERATION_CHECK)
@@ -1812,7 +1954,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
     def add_unknown_feature(self, operation):
         with Repository(self.repository_path, exclusive=True) as repository:
             manifest, key = Manifest.load(repository, Manifest.NO_OPERATION_CHECK)
-            manifest.config['feature_flags'] = {operation.value: {'mandatory': ['unknown-feature']}}
+            manifest.config["feature_flags"] = {operation.value: {"mandatory": ["unknown-feature"]}}
             manifest.write()
             repository.commit(compact=False)
 
@@ -1822,68 +1964,68 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         else:
             with pytest.raises(MandatoryFeatureUnsupported) as excinfo:
                 self.cmd(*args)
-            assert excinfo.value.args == (['unknown-feature'],)
+            assert excinfo.value.args == (["unknown-feature"],)
 
     def test_unknown_feature_on_create(self):
-        print(self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION))
+        print(self.cmd(f"--repo={self.repository_location}", "rcreate", RK_ENCRYPTION))
         self.add_unknown_feature(Manifest.Operation.WRITE)
-        self.cmd_raises_unknown_feature([f'--repo={self.repository_location}', 'create', 'test', 'input'])
+        self.cmd_raises_unknown_feature([f"--repo={self.repository_location}", "create", "test", "input"])
 
     def test_unknown_feature_on_cache_sync(self):
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
-        self.cmd(f'--repo={self.repository_location}', 'rdelete', '--cache-only')
+        self.cmd(f"--repo={self.repository_location}", "rcreate", RK_ENCRYPTION)
+        self.cmd(f"--repo={self.repository_location}", "rdelete", "--cache-only")
         self.add_unknown_feature(Manifest.Operation.READ)
-        self.cmd_raises_unknown_feature([f'--repo={self.repository_location}', 'create', 'test', 'input'])
+        self.cmd_raises_unknown_feature([f"--repo={self.repository_location}", "create", "test", "input"])
 
     def test_unknown_feature_on_change_passphrase(self):
-        print(self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION))
+        print(self.cmd(f"--repo={self.repository_location}", "rcreate", RK_ENCRYPTION))
         self.add_unknown_feature(Manifest.Operation.CHECK)
-        self.cmd_raises_unknown_feature([f'--repo={self.repository_location}', 'key', 'change-passphrase'])
+        self.cmd_raises_unknown_feature([f"--repo={self.repository_location}", "key", "change-passphrase"])
 
     def test_unknown_feature_on_read(self):
-        print(self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION))
-        self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
+        print(self.cmd(f"--repo={self.repository_location}", "rcreate", RK_ENCRYPTION))
+        self.cmd(f"--repo={self.repository_location}", "create", "test", "input")
         self.add_unknown_feature(Manifest.Operation.READ)
-        with changedir('output'):
-            self.cmd_raises_unknown_feature([f'--repo={self.repository_location}', 'extract', 'test'])
+        with changedir("output"):
+            self.cmd_raises_unknown_feature([f"--repo={self.repository_location}", "extract", "test"])
 
-        self.cmd_raises_unknown_feature([f'--repo={self.repository_location}', 'rlist'])
-        self.cmd_raises_unknown_feature([f'--repo={self.repository_location}', 'info', '-a', 'test'])
+        self.cmd_raises_unknown_feature([f"--repo={self.repository_location}", "rlist"])
+        self.cmd_raises_unknown_feature([f"--repo={self.repository_location}", "info", "-a", "test"])
 
     def test_unknown_feature_on_rename(self):
-        print(self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION))
-        self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
+        print(self.cmd(f"--repo={self.repository_location}", "rcreate", RK_ENCRYPTION))
+        self.cmd(f"--repo={self.repository_location}", "create", "test", "input")
         self.add_unknown_feature(Manifest.Operation.CHECK)
-        self.cmd_raises_unknown_feature([f'--repo={self.repository_location}', 'rename', 'test', 'other'])
+        self.cmd_raises_unknown_feature([f"--repo={self.repository_location}", "rename", "test", "other"])
 
     def test_unknown_feature_on_delete(self):
-        print(self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION))
-        self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
+        print(self.cmd(f"--repo={self.repository_location}", "rcreate", RK_ENCRYPTION))
+        self.cmd(f"--repo={self.repository_location}", "create", "test", "input")
         self.add_unknown_feature(Manifest.Operation.DELETE)
         # delete of an archive raises
-        self.cmd_raises_unknown_feature([f'--repo={self.repository_location}', 'delete', '-a', 'test'])
-        self.cmd_raises_unknown_feature([f'--repo={self.repository_location}', 'prune', '--keep-daily=3'])
+        self.cmd_raises_unknown_feature([f"--repo={self.repository_location}", "delete", "-a", "test"])
+        self.cmd_raises_unknown_feature([f"--repo={self.repository_location}", "prune", "--keep-daily=3"])
         # delete of the whole repository ignores features
-        self.cmd(f'--repo={self.repository_location}', 'rdelete')
+        self.cmd(f"--repo={self.repository_location}", "rdelete")
 
-    @unittest.skipUnless(llfuse, 'llfuse not installed')
+    @unittest.skipUnless(llfuse, "llfuse not installed")
     def test_unknown_feature_on_mount(self):
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
-        self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
+        self.cmd(f"--repo={self.repository_location}", "rcreate", RK_ENCRYPTION)
+        self.cmd(f"--repo={self.repository_location}", "create", "test", "input")
         self.add_unknown_feature(Manifest.Operation.READ)
-        mountpoint = os.path.join(self.tmpdir, 'mountpoint')
+        mountpoint = os.path.join(self.tmpdir, "mountpoint")
         os.mkdir(mountpoint)
         # XXX this might hang if it doesn't raise an error
-        self.cmd_raises_unknown_feature([f'--repo={self.repository_location}::test', 'mount', mountpoint])
+        self.cmd_raises_unknown_feature([f"--repo={self.repository_location}::test", "mount", mountpoint])
 
     @pytest.mark.allow_cache_wipe
     def test_unknown_mandatory_feature_in_cache(self):
         if self.prefix:
-            path_prefix = 'ssh://__testsuite__'
+            path_prefix = "ssh://__testsuite__"
         else:
-            path_prefix = ''
+            path_prefix = ""
 
-        print(self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION))
+        print(self.cmd(f"--repo={self.repository_location}", "rcreate", RK_ENCRYPTION))
 
         with Repository(self.repository_path, exclusive=True) as repository:
             if path_prefix:
@@ -1891,11 +2033,11 @@ class ArchiverTestCase(ArchiverTestCaseBase):
             manifest, key = Manifest.load(repository, Manifest.NO_OPERATION_CHECK)
             with Cache(repository, key, manifest) as cache:
                 cache.begin_txn()
-                cache.cache_config.mandatory_features = {'unknown-feature'}
+                cache.cache_config.mandatory_features = {"unknown-feature"}
                 cache.commit()
 
         if self.FORK_DEFAULT:
-            self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
+            self.cmd(f"--repo={self.repository_location}", "create", "test", "input")
         else:
             called = False
             wipe_cache_safe = LocalCache.wipe_cache
@@ -1905,8 +2047,8 @@ class ArchiverTestCase(ArchiverTestCaseBase):
                 called = True
                 wipe_cache_safe(*args)
 
-            with patch.object(LocalCache, 'wipe_cache', wipe_wrapper):
-                self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
+            with patch.object(LocalCache, "wipe_cache", wipe_wrapper):
+                self.cmd(f"--repo={self.repository_location}", "create", "test", "input")
 
             assert called
 
@@ -1918,30 +2060,30 @@ class ArchiverTestCase(ArchiverTestCaseBase):
                 assert cache.cache_config.mandatory_features == set()
 
     def test_progress_on(self):
-        self.create_regular_file('file1', size=1024 * 80)
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
-        output = self.cmd(f'--repo={self.repository_location}', 'create', 'test4', 'input', '--progress')
+        self.create_regular_file("file1", size=1024 * 80)
+        self.cmd(f"--repo={self.repository_location}", "rcreate", RK_ENCRYPTION)
+        output = self.cmd(f"--repo={self.repository_location}", "create", "test4", "input", "--progress")
         self.assert_in("\r", output)
 
     def test_progress_off(self):
-        self.create_regular_file('file1', size=1024 * 80)
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
-        output = self.cmd(f'--repo={self.repository_location}', 'create', 'test5', 'input')
+        self.create_regular_file("file1", size=1024 * 80)
+        self.cmd(f"--repo={self.repository_location}", "rcreate", RK_ENCRYPTION)
+        output = self.cmd(f"--repo={self.repository_location}", "create", "test5", "input")
         self.assert_not_in("\r", output)
 
     def test_file_status(self):
         """test that various file status show expected results
 
         clearly incomplete: only tests for the weird "unchanged" status for now"""
-        self.create_regular_file('file1', size=1024 * 80)
+        self.create_regular_file("file1", size=1024 * 80)
         time.sleep(1)  # file2 must have newer timestamps than file1
-        self.create_regular_file('file2', size=1024 * 80)
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
-        output = self.cmd(f'--repo={self.repository_location}', 'create', '--list', 'test', 'input')
+        self.create_regular_file("file2", size=1024 * 80)
+        self.cmd(f"--repo={self.repository_location}", "rcreate", RK_ENCRYPTION)
+        output = self.cmd(f"--repo={self.repository_location}", "create", "--list", "test", "input")
         self.assert_in("A input/file1", output)
         self.assert_in("A input/file2", output)
         # should find first file as unmodified
-        output = self.cmd(f'--repo={self.repository_location}', 'create', '--list', 'test2', 'input')
+        output = self.cmd(f"--repo={self.repository_location}", "create", "--list", "test2", "input")
         self.assert_in("U input/file1", output)
         # this is expected, although surprising, for why, see:
         # https://borgbackup.readthedocs.org/en/latest/faq.html#i-am-seeing-a-added-status-for-a-unchanged-file
@@ -1949,115 +2091,128 @@ class ArchiverTestCase(ArchiverTestCaseBase):
 
     def test_file_status_cs_cache_mode(self):
         """test that a changed file with faked "previous" mtime still gets backed up in ctime,size cache_mode"""
-        self.create_regular_file('file1', contents=b'123')
+        self.create_regular_file("file1", contents=b"123")
         time.sleep(1)  # file2 must have newer timestamps than file1
-        self.create_regular_file('file2', size=10)
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
-        output = self.cmd(f'--repo={self.repository_location}', 'create', 'test1', 'input',
-                          '--list', '--files-cache=ctime,size')
+        self.create_regular_file("file2", size=10)
+        self.cmd(f"--repo={self.repository_location}", "rcreate", RK_ENCRYPTION)
+        output = self.cmd(
+            f"--repo={self.repository_location}", "create", "test1", "input", "--list", "--files-cache=ctime,size"
+        )
         # modify file1, but cheat with the mtime (and atime) and also keep same size:
-        st = os.stat('input/file1')
-        self.create_regular_file('file1', contents=b'321')
-        os.utime('input/file1', ns=(st.st_atime_ns, st.st_mtime_ns))
+        st = os.stat("input/file1")
+        self.create_regular_file("file1", contents=b"321")
+        os.utime("input/file1", ns=(st.st_atime_ns, st.st_mtime_ns))
         # this mode uses ctime for change detection, so it should find file1 as modified
-        output = self.cmd(f'--repo={self.repository_location}', 'create', 'test2', 'input',
-                          '--list', '--files-cache=ctime,size')
+        output = self.cmd(
+            f"--repo={self.repository_location}", "create", "test2", "input", "--list", "--files-cache=ctime,size"
+        )
         self.assert_in("M input/file1", output)
 
     def test_file_status_ms_cache_mode(self):
         """test that a chmod'ed file with no content changes does not get chunked again in mtime,size cache_mode"""
-        self.create_regular_file('file1', size=10)
+        self.create_regular_file("file1", size=10)
         time.sleep(1)  # file2 must have newer timestamps than file1
-        self.create_regular_file('file2', size=10)
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
-        output = self.cmd(f'--repo={self.repository_location}', 'create',
-                          '--list', '--files-cache=mtime,size', 'test1', 'input')
+        self.create_regular_file("file2", size=10)
+        self.cmd(f"--repo={self.repository_location}", "rcreate", RK_ENCRYPTION)
+        output = self.cmd(
+            f"--repo={self.repository_location}", "create", "--list", "--files-cache=mtime,size", "test1", "input"
+        )
         # change mode of file1, no content change:
-        st = os.stat('input/file1')
-        os.chmod('input/file1', st.st_mode ^ stat.S_IRWXO)  # this triggers a ctime change, but mtime is unchanged
+        st = os.stat("input/file1")
+        os.chmod("input/file1", st.st_mode ^ stat.S_IRWXO)  # this triggers a ctime change, but mtime is unchanged
         # this mode uses mtime for change detection, so it should find file1 as unmodified
-        output = self.cmd(f'--repo={self.repository_location}', 'create',
-                          '--list', '--files-cache=mtime,size', 'test2', 'input')
+        output = self.cmd(
+            f"--repo={self.repository_location}", "create", "--list", "--files-cache=mtime,size", "test2", "input"
+        )
         self.assert_in("U input/file1", output)
 
     def test_file_status_rc_cache_mode(self):
         """test that files get rechunked unconditionally in rechunk,ctime cache mode"""
-        self.create_regular_file('file1', size=10)
+        self.create_regular_file("file1", size=10)
         time.sleep(1)  # file2 must have newer timestamps than file1
-        self.create_regular_file('file2', size=10)
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
-        output = self.cmd(f'--repo={self.repository_location}', 'create',
-                          '--list', '--files-cache=rechunk,ctime', 'test1', 'input')
+        self.create_regular_file("file2", size=10)
+        self.cmd(f"--repo={self.repository_location}", "rcreate", RK_ENCRYPTION)
+        output = self.cmd(
+            f"--repo={self.repository_location}", "create", "--list", "--files-cache=rechunk,ctime", "test1", "input"
+        )
         # no changes here, but this mode rechunks unconditionally
-        output = self.cmd(f'--repo={self.repository_location}', 'create',
-                          '--list', '--files-cache=rechunk,ctime', 'test2', 'input')
+        output = self.cmd(
+            f"--repo={self.repository_location}", "create", "--list", "--files-cache=rechunk,ctime", "test2", "input"
+        )
         self.assert_in("A input/file1", output)
 
     def test_file_status_excluded(self):
         """test that excluded paths are listed"""
 
-        self.create_regular_file('file1', size=1024 * 80)
+        self.create_regular_file("file1", size=1024 * 80)
         time.sleep(1)  # file2 must have newer timestamps than file1
-        self.create_regular_file('file2', size=1024 * 80)
+        self.create_regular_file("file2", size=1024 * 80)
         if has_lchflags:
-            self.create_regular_file('file3', size=1024 * 80)
-            platform.set_flags(os.path.join(self.input_path, 'file3'), stat.UF_NODUMP)
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
-        output = self.cmd(f'--repo={self.repository_location}', 'create', '--list', '--exclude-nodump', 'test', 'input')
+            self.create_regular_file("file3", size=1024 * 80)
+            platform.set_flags(os.path.join(self.input_path, "file3"), stat.UF_NODUMP)
+        self.cmd(f"--repo={self.repository_location}", "rcreate", RK_ENCRYPTION)
+        output = self.cmd(f"--repo={self.repository_location}", "create", "--list", "--exclude-nodump", "test", "input")
         self.assert_in("A input/file1", output)
         self.assert_in("A input/file2", output)
         if has_lchflags:
             self.assert_in("x input/file3", output)
         # should find second file as excluded
-        output = self.cmd(f'--repo={self.repository_location}', 'create', 'test1', 'input',
-                          '--list', '--exclude-nodump', '--exclude', '*/file2')
+        output = self.cmd(
+            f"--repo={self.repository_location}",
+            "create",
+            "test1",
+            "input",
+            "--list",
+            "--exclude-nodump",
+            "--exclude",
+            "*/file2",
+        )
         self.assert_in("U input/file1", output)
         self.assert_in("x input/file2", output)
         if has_lchflags:
             self.assert_in("x input/file3", output)
 
     def test_create_json(self):
-        self.create_regular_file('file1', size=1024 * 80)
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
-        create_info = json.loads(self.cmd(f'--repo={self.repository_location}', 'create', '--json',
-                                          'test', 'input'))
+        self.create_regular_file("file1", size=1024 * 80)
+        self.cmd(f"--repo={self.repository_location}", "rcreate", RK_ENCRYPTION)
+        create_info = json.loads(self.cmd(f"--repo={self.repository_location}", "create", "--json", "test", "input"))
         # The usual keys
-        assert 'encryption' in create_info
-        assert 'repository' in create_info
-        assert 'cache' in create_info
-        assert 'last_modified' in create_info['repository']
+        assert "encryption" in create_info
+        assert "repository" in create_info
+        assert "cache" in create_info
+        assert "last_modified" in create_info["repository"]
 
-        archive = create_info['archive']
-        assert archive['name'] == 'test'
-        assert isinstance(archive['command_line'], list)
-        assert isinstance(archive['duration'], float)
-        assert len(archive['id']) == 64
-        assert 'stats' in archive
+        archive = create_info["archive"]
+        assert archive["name"] == "test"
+        assert isinstance(archive["command_line"], list)
+        assert isinstance(archive["duration"], float)
+        assert len(archive["id"]) == 64
+        assert "stats" in archive
 
     def test_create_topical(self):
-        self.create_regular_file('file1', size=1024 * 80)
+        self.create_regular_file("file1", size=1024 * 80)
         time.sleep(1)  # file2 must have newer timestamps than file1
-        self.create_regular_file('file2', size=1024 * 80)
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
+        self.create_regular_file("file2", size=1024 * 80)
+        self.cmd(f"--repo={self.repository_location}", "rcreate", RK_ENCRYPTION)
         # no listing by default
-        output = self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
-        self.assert_not_in('file1', output)
+        output = self.cmd(f"--repo={self.repository_location}", "create", "test", "input")
+        self.assert_not_in("file1", output)
         # shouldn't be listed even if unchanged
-        output = self.cmd(f'--repo={self.repository_location}', 'create', 'test0', 'input')
-        self.assert_not_in('file1', output)
+        output = self.cmd(f"--repo={self.repository_location}", "create", "test0", "input")
+        self.assert_not_in("file1", output)
         # should list the file as unchanged
-        output = self.cmd(f'--repo={self.repository_location}', 'create', 'test1', 'input', '--list', '--filter=U')
-        self.assert_in('file1', output)
+        output = self.cmd(f"--repo={self.repository_location}", "create", "test1", "input", "--list", "--filter=U")
+        self.assert_in("file1", output)
         # should *not* list the file as changed
-        output = self.cmd(f'--repo={self.repository_location}', 'create', 'test2', 'input', '--list', '--filter=AM')
-        self.assert_not_in('file1', output)
+        output = self.cmd(f"--repo={self.repository_location}", "create", "test2", "input", "--list", "--filter=AM")
+        self.assert_not_in("file1", output)
         # change the file
-        self.create_regular_file('file1', size=1024 * 100)
+        self.create_regular_file("file1", size=1024 * 100)
         # should list the file as changed
-        output = self.cmd(f'--repo={self.repository_location}', 'create', 'test3', 'input', '--list', '--filter=AM')
-        self.assert_in('file1', output)
+        output = self.cmd(f"--repo={self.repository_location}", "create", "test3", "input", "--list", "--filter=AM")
+        self.assert_in("file1", output)
 
-    @pytest.mark.skipif(not are_fifos_supported(), reason='FIFOs not supported')
+    @pytest.mark.skipif(not are_fifos_supported(), reason="FIFOs not supported")
     def test_create_read_special_symlink(self):
         from threading import Thread
 
@@ -2068,33 +2223,33 @@ class ArchiverTestCase(ArchiverTestCaseBase):
             finally:
                 os.close(fd)
 
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
-        data = b'foobar' * 1000
+        self.cmd(f"--repo={self.repository_location}", "rcreate", RK_ENCRYPTION)
+        data = b"foobar" * 1000
 
-        fifo_fn = os.path.join(self.input_path, 'fifo')
-        link_fn = os.path.join(self.input_path, 'link_fifo')
+        fifo_fn = os.path.join(self.input_path, "fifo")
+        link_fn = os.path.join(self.input_path, "link_fifo")
         os.mkfifo(fifo_fn)
         os.symlink(fifo_fn, link_fn)
 
         t = Thread(target=fifo_feeder, args=(fifo_fn, data))
         t.start()
         try:
-            self.cmd(f'--repo={self.repository_location}', 'create', '--read-special', 'test', 'input/link_fifo')
+            self.cmd(f"--repo={self.repository_location}", "create", "--read-special", "test", "input/link_fifo")
         finally:
             t.join()
-        with changedir('output'):
-            self.cmd(f'--repo={self.repository_location}', 'extract', 'test')
-            fifo_fn = 'input/link_fifo'
-            with open(fifo_fn, 'rb') as f:
+        with changedir("output"):
+            self.cmd(f"--repo={self.repository_location}", "extract", "test")
+            fifo_fn = "input/link_fifo"
+            with open(fifo_fn, "rb") as f:
                 extracted_data = f.read()
         assert extracted_data == data
 
     def test_create_read_special_broken_symlink(self):
-        os.symlink('somewhere does not exist', os.path.join(self.input_path, 'link'))
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
-        self.cmd(f'--repo={self.repository_location}', 'create', '--read-special', 'test', 'input')
-        output = self.cmd(f'--repo={self.repository_location}', 'list', 'test')
-        assert 'input/link -> somewhere does not exist' in output
+        os.symlink("somewhere does not exist", os.path.join(self.input_path, "link"))
+        self.cmd(f"--repo={self.repository_location}", "rcreate", RK_ENCRYPTION)
+        self.cmd(f"--repo={self.repository_location}", "create", "--read-special", "test", "input")
+        output = self.cmd(f"--repo={self.repository_location}", "list", "test")
+        assert "input/link -> somewhere does not exist" in output
 
     # def test_cmdline_compatibility(self):
     #    self.create_regular_file('file1', size=1024 * 80)
@@ -2104,42 +2259,42 @@ class ArchiverTestCase(ArchiverTestCaseBase):
     #    self.assert_in('"--old" has been deprecated. Use "--new" instead', output)
 
     def test_prune_repository(self):
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
-        self.cmd(f'--repo={self.repository_location}', 'create', 'test1', src_dir)
-        self.cmd(f'--repo={self.repository_location}', 'create', 'test2', src_dir)
+        self.cmd(f"--repo={self.repository_location}", "rcreate", RK_ENCRYPTION)
+        self.cmd(f"--repo={self.repository_location}", "create", "test1", src_dir)
+        self.cmd(f"--repo={self.repository_location}", "create", "test2", src_dir)
         # these are not really a checkpoints, but they look like some:
-        self.cmd(f'--repo={self.repository_location}', 'create', 'test3.checkpoint', src_dir)
-        self.cmd(f'--repo={self.repository_location}', 'create', 'test3.checkpoint.1', src_dir)
-        self.cmd(f'--repo={self.repository_location}', 'create', 'test4.checkpoint', src_dir)
-        output = self.cmd(f'--repo={self.repository_location}', 'prune', '--list', '--dry-run', '--keep-daily=1')
-        assert re.search(r'Would prune:\s+test1', output)
+        self.cmd(f"--repo={self.repository_location}", "create", "test3.checkpoint", src_dir)
+        self.cmd(f"--repo={self.repository_location}", "create", "test3.checkpoint.1", src_dir)
+        self.cmd(f"--repo={self.repository_location}", "create", "test4.checkpoint", src_dir)
+        output = self.cmd(f"--repo={self.repository_location}", "prune", "--list", "--dry-run", "--keep-daily=1")
+        assert re.search(r"Would prune:\s+test1", output)
         # must keep the latest non-checkpoint archive:
-        assert re.search(r'Keeping archive \(rule: daily #1\):\s+test2', output)
+        assert re.search(r"Keeping archive \(rule: daily #1\):\s+test2", output)
         # must keep the latest checkpoint archive:
-        assert re.search(r'Keeping checkpoint archive:\s+test4.checkpoint', output)
-        output = self.cmd(f'--repo={self.repository_location}', 'rlist', '--consider-checkpoints')
-        self.assert_in('test1', output)
-        self.assert_in('test2', output)
-        self.assert_in('test3.checkpoint', output)
-        self.assert_in('test3.checkpoint.1', output)
-        self.assert_in('test4.checkpoint', output)
-        self.cmd(f'--repo={self.repository_location}', 'prune', '--keep-daily=1')
-        output = self.cmd(f'--repo={self.repository_location}', 'rlist', '--consider-checkpoints')
-        self.assert_not_in('test1', output)
+        assert re.search(r"Keeping checkpoint archive:\s+test4.checkpoint", output)
+        output = self.cmd(f"--repo={self.repository_location}", "rlist", "--consider-checkpoints")
+        self.assert_in("test1", output)
+        self.assert_in("test2", output)
+        self.assert_in("test3.checkpoint", output)
+        self.assert_in("test3.checkpoint.1", output)
+        self.assert_in("test4.checkpoint", output)
+        self.cmd(f"--repo={self.repository_location}", "prune", "--keep-daily=1")
+        output = self.cmd(f"--repo={self.repository_location}", "rlist", "--consider-checkpoints")
+        self.assert_not_in("test1", output)
         # the latest non-checkpoint archive must be still there:
-        self.assert_in('test2', output)
+        self.assert_in("test2", output)
         # only the latest checkpoint archive must still be there:
-        self.assert_not_in('test3.checkpoint', output)
-        self.assert_not_in('test3.checkpoint.1', output)
-        self.assert_in('test4.checkpoint', output)
+        self.assert_not_in("test3.checkpoint", output)
+        self.assert_not_in("test3.checkpoint.1", output)
+        self.assert_in("test4.checkpoint", output)
         # now we supersede the latest checkpoint by a successful backup:
-        self.cmd(f'--repo={self.repository_location}', 'create', 'test5', src_dir)
-        self.cmd(f'--repo={self.repository_location}', 'prune', '--keep-daily=2')
-        output = self.cmd(f'--repo={self.repository_location}', 'rlist', '--consider-checkpoints')
+        self.cmd(f"--repo={self.repository_location}", "create", "test5", src_dir)
+        self.cmd(f"--repo={self.repository_location}", "prune", "--keep-daily=2")
+        output = self.cmd(f"--repo={self.repository_location}", "rlist", "--consider-checkpoints")
         # all checkpoints should be gone now:
-        self.assert_not_in('checkpoint', output)
+        self.assert_not_in("checkpoint", output)
         # the latest archive must be still there
-        self.assert_in('test5', output)
+        self.assert_in("test5", output)
 
     # Given a date and time in local tz, create a UTC timestamp string suitable
     # for create --timestamp command line option
@@ -2148,351 +2303,399 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         return dtime.astimezone(dateutil.tz.UTC).strftime("%Y-%m-%dT%H:%M:%S")
 
     def _create_archive_ts(self, name, y, m, d, H=0, M=0, S=0):
-        self.cmd(f'--repo={self.repository_location}', 'create',
-                 '--timestamp', self._to_utc_timestamp(y, m, d, H, M, S), name, src_dir)
+        self.cmd(
+            f"--repo={self.repository_location}",
+            "create",
+            "--timestamp",
+            self._to_utc_timestamp(y, m, d, H, M, S),
+            name,
+            src_dir,
+        )
 
     # This test must match docs/misc/prune-example.txt
     def test_prune_repository_example(self):
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
+        self.cmd(f"--repo={self.repository_location}", "rcreate", RK_ENCRYPTION)
         # Archives that will be kept, per the example
         # Oldest archive
-        self._create_archive_ts('test01', 2015, 1, 1)
+        self._create_archive_ts("test01", 2015, 1, 1)
         # 6 monthly archives
-        self._create_archive_ts('test02', 2015, 6, 30)
-        self._create_archive_ts('test03', 2015, 7, 31)
-        self._create_archive_ts('test04', 2015, 8, 31)
-        self._create_archive_ts('test05', 2015, 9, 30)
-        self._create_archive_ts('test06', 2015, 10, 31)
-        self._create_archive_ts('test07', 2015, 11, 30)
+        self._create_archive_ts("test02", 2015, 6, 30)
+        self._create_archive_ts("test03", 2015, 7, 31)
+        self._create_archive_ts("test04", 2015, 8, 31)
+        self._create_archive_ts("test05", 2015, 9, 30)
+        self._create_archive_ts("test06", 2015, 10, 31)
+        self._create_archive_ts("test07", 2015, 11, 30)
         # 14 daily archives
-        self._create_archive_ts('test08', 2015, 12, 17)
-        self._create_archive_ts('test09', 2015, 12, 18)
-        self._create_archive_ts('test10', 2015, 12, 20)
-        self._create_archive_ts('test11', 2015, 12, 21)
-        self._create_archive_ts('test12', 2015, 12, 22)
-        self._create_archive_ts('test13', 2015, 12, 23)
-        self._create_archive_ts('test14', 2015, 12, 24)
-        self._create_archive_ts('test15', 2015, 12, 25)
-        self._create_archive_ts('test16', 2015, 12, 26)
-        self._create_archive_ts('test17', 2015, 12, 27)
-        self._create_archive_ts('test18', 2015, 12, 28)
-        self._create_archive_ts('test19', 2015, 12, 29)
-        self._create_archive_ts('test20', 2015, 12, 30)
-        self._create_archive_ts('test21', 2015, 12, 31)
+        self._create_archive_ts("test08", 2015, 12, 17)
+        self._create_archive_ts("test09", 2015, 12, 18)
+        self._create_archive_ts("test10", 2015, 12, 20)
+        self._create_archive_ts("test11", 2015, 12, 21)
+        self._create_archive_ts("test12", 2015, 12, 22)
+        self._create_archive_ts("test13", 2015, 12, 23)
+        self._create_archive_ts("test14", 2015, 12, 24)
+        self._create_archive_ts("test15", 2015, 12, 25)
+        self._create_archive_ts("test16", 2015, 12, 26)
+        self._create_archive_ts("test17", 2015, 12, 27)
+        self._create_archive_ts("test18", 2015, 12, 28)
+        self._create_archive_ts("test19", 2015, 12, 29)
+        self._create_archive_ts("test20", 2015, 12, 30)
+        self._create_archive_ts("test21", 2015, 12, 31)
         # Additional archives that would be pruned
         # The second backup of the year
-        self._create_archive_ts('test22', 2015, 1, 2)
+        self._create_archive_ts("test22", 2015, 1, 2)
         # The next older monthly backup
-        self._create_archive_ts('test23', 2015, 5, 31)
+        self._create_archive_ts("test23", 2015, 5, 31)
         # The next older daily backup
-        self._create_archive_ts('test24', 2015, 12, 16)
-        output = self.cmd(f'--repo={self.repository_location}', 'prune', '--list', '--dry-run', '--keep-daily=14', '--keep-monthly=6', '--keep-yearly=1')
+        self._create_archive_ts("test24", 2015, 12, 16)
+        output = self.cmd(
+            f"--repo={self.repository_location}",
+            "prune",
+            "--list",
+            "--dry-run",
+            "--keep-daily=14",
+            "--keep-monthly=6",
+            "--keep-yearly=1",
+        )
         # Prune second backup of the year
-        assert re.search(r'Would prune:\s+test22', output)
+        assert re.search(r"Would prune:\s+test22", output)
         # Prune next older monthly and daily backups
-        assert re.search(r'Would prune:\s+test23', output)
-        assert re.search(r'Would prune:\s+test24', output)
+        assert re.search(r"Would prune:\s+test23", output)
+        assert re.search(r"Would prune:\s+test24", output)
         # Must keep the other 21 backups
         # Yearly is kept as oldest archive
-        assert re.search(r'Keeping archive \(rule: yearly\[oldest\] #1\):\s+test01', output)
+        assert re.search(r"Keeping archive \(rule: yearly\[oldest\] #1\):\s+test01", output)
         for i in range(1, 7):
-            assert re.search(r'Keeping archive \(rule: monthly #' + str(i) + r'\):\s+test' + ("%02d" % (8-i)), output)
+            assert re.search(r"Keeping archive \(rule: monthly #" + str(i) + r"\):\s+test" + ("%02d" % (8 - i)), output)
         for i in range(1, 15):
-            assert re.search(r'Keeping archive \(rule: daily #' + str(i) + r'\):\s+test' + ("%02d" % (22-i)), output)
-        output = self.cmd(f'--repo={self.repository_location}', 'rlist')
+            assert re.search(r"Keeping archive \(rule: daily #" + str(i) + r"\):\s+test" + ("%02d" % (22 - i)), output)
+        output = self.cmd(f"--repo={self.repository_location}", "rlist")
         # Nothing pruned after dry run
         for i in range(1, 25):
-            self.assert_in('test%02d' % i, output)
-        self.cmd(f'--repo={self.repository_location}', 'prune', '--keep-daily=14', '--keep-monthly=6', '--keep-yearly=1')
-        output = self.cmd(f'--repo={self.repository_location}', 'rlist')
+            self.assert_in("test%02d" % i, output)
+        self.cmd(
+            f"--repo={self.repository_location}", "prune", "--keep-daily=14", "--keep-monthly=6", "--keep-yearly=1"
+        )
+        output = self.cmd(f"--repo={self.repository_location}", "rlist")
         # All matching backups plus oldest kept
         for i in range(1, 22):
-            self.assert_in('test%02d' % i, output)
+            self.assert_in("test%02d" % i, output)
         # Other backups have been pruned
         for i in range(22, 25):
-            self.assert_not_in('test%02d' % i, output)
+            self.assert_not_in("test%02d" % i, output)
 
     # With an initial and daily backup, prune daily until oldest is replaced by a monthly backup
     def test_prune_retain_and_expire_oldest(self):
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
+        self.cmd(f"--repo={self.repository_location}", "rcreate", RK_ENCRYPTION)
         # Initial backup
-        self._create_archive_ts('original_archive', 2020, 9, 1, 11, 15)
+        self._create_archive_ts("original_archive", 2020, 9, 1, 11, 15)
         # Archive and prune daily for 30 days
         for i in range(1, 31):
-            self._create_archive_ts('september%02d' % i, 2020, 9, i, 12)
-            self.cmd(f'--repo={self.repository_location}', 'prune', '--keep-daily=7', '--keep-monthly=1')
+            self._create_archive_ts("september%02d" % i, 2020, 9, i, 12)
+            self.cmd(f"--repo={self.repository_location}", "prune", "--keep-daily=7", "--keep-monthly=1")
         # Archive and prune 6 days into the next month
         for i in range(1, 7):
-            self._create_archive_ts('october%02d' % i, 2020, 10, i, 12)
-            self.cmd(f'--repo={self.repository_location}', 'prune', '--keep-daily=7', '--keep-monthly=1')
+            self._create_archive_ts("october%02d" % i, 2020, 10, i, 12)
+            self.cmd(f"--repo={self.repository_location}", "prune", "--keep-daily=7", "--keep-monthly=1")
         # Oldest backup is still retained
-        output = self.cmd(f'--repo={self.repository_location}', 'prune', '--list', '--dry-run', '--keep-daily=7', '--keep-monthly=1')
-        assert re.search(r'Keeping archive \(rule: monthly\[oldest\] #1' + r'\):\s+original_archive', output)
+        output = self.cmd(
+            f"--repo={self.repository_location}", "prune", "--list", "--dry-run", "--keep-daily=7", "--keep-monthly=1"
+        )
+        assert re.search(r"Keeping archive \(rule: monthly\[oldest\] #1" + r"\):\s+original_archive", output)
         # Archive one more day and prune.
-        self._create_archive_ts('october07', 2020, 10, 7, 12)
-        self.cmd(f'--repo={self.repository_location}', 'prune', '--keep-daily=7', '--keep-monthly=1')
+        self._create_archive_ts("october07", 2020, 10, 7, 12)
+        self.cmd(f"--repo={self.repository_location}", "prune", "--keep-daily=7", "--keep-monthly=1")
         # Last day of previous month is retained as monthly, and oldest is expired.
-        output = self.cmd(f'--repo={self.repository_location}', 'prune', '--list', '--dry-run', '--keep-daily=7', '--keep-monthly=1')
-        assert re.search(r'Keeping archive \(rule: monthly #1\):\s+september30', output)
-        self.assert_not_in('original_archive', output)
+        output = self.cmd(
+            f"--repo={self.repository_location}", "prune", "--list", "--dry-run", "--keep-daily=7", "--keep-monthly=1"
+        )
+        assert re.search(r"Keeping archive \(rule: monthly #1\):\s+september30", output)
+        self.assert_not_in("original_archive", output)
 
     def test_prune_repository_save_space(self):
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
-        self.cmd(f'--repo={self.repository_location}', 'create', 'test1', src_dir)
-        self.cmd(f'--repo={self.repository_location}', 'create', 'test2', src_dir)
-        output = self.cmd(f'--repo={self.repository_location}', 'prune', '--list', '--dry-run', '--keep-daily=1')
-        assert re.search(r'Keeping archive \(rule: daily #1\):\s+test2', output)
-        assert re.search(r'Would prune:\s+test1', output)
-        output = self.cmd(f'--repo={self.repository_location}', 'rlist')
-        self.assert_in('test1', output)
-        self.assert_in('test2', output)
-        self.cmd(f'--repo={self.repository_location}', 'prune', '--save-space', '--keep-daily=1')
-        output = self.cmd(f'--repo={self.repository_location}', 'rlist')
-        self.assert_not_in('test1', output)
-        self.assert_in('test2', output)
+        self.cmd(f"--repo={self.repository_location}", "rcreate", RK_ENCRYPTION)
+        self.cmd(f"--repo={self.repository_location}", "create", "test1", src_dir)
+        self.cmd(f"--repo={self.repository_location}", "create", "test2", src_dir)
+        output = self.cmd(f"--repo={self.repository_location}", "prune", "--list", "--dry-run", "--keep-daily=1")
+        assert re.search(r"Keeping archive \(rule: daily #1\):\s+test2", output)
+        assert re.search(r"Would prune:\s+test1", output)
+        output = self.cmd(f"--repo={self.repository_location}", "rlist")
+        self.assert_in("test1", output)
+        self.assert_in("test2", output)
+        self.cmd(f"--repo={self.repository_location}", "prune", "--save-space", "--keep-daily=1")
+        output = self.cmd(f"--repo={self.repository_location}", "rlist")
+        self.assert_not_in("test1", output)
+        self.assert_in("test2", output)
 
     def test_prune_repository_prefix(self):
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
-        self.cmd(f'--repo={self.repository_location}', 'create', 'foo-2015-08-12-10:00', src_dir)
-        self.cmd(f'--repo={self.repository_location}', 'create', 'foo-2015-08-12-20:00', src_dir)
-        self.cmd(f'--repo={self.repository_location}', 'create', 'bar-2015-08-12-10:00', src_dir)
-        self.cmd(f'--repo={self.repository_location}', 'create', 'bar-2015-08-12-20:00', src_dir)
-        output = self.cmd(f'--repo={self.repository_location}', 'prune', '--list', '--dry-run', '--keep-daily=1', '--glob-archives=foo-*')
-        assert re.search(r'Keeping archive \(rule: daily #1\):\s+foo-2015-08-12-20:00', output)
-        assert re.search(r'Would prune:\s+foo-2015-08-12-10:00', output)
-        output = self.cmd(f'--repo={self.repository_location}', 'rlist')
-        self.assert_in('foo-2015-08-12-10:00', output)
-        self.assert_in('foo-2015-08-12-20:00', output)
-        self.assert_in('bar-2015-08-12-10:00', output)
-        self.assert_in('bar-2015-08-12-20:00', output)
-        self.cmd(f'--repo={self.repository_location}', 'prune', '--keep-daily=1', '--glob-archives=foo-*')
-        output = self.cmd(f'--repo={self.repository_location}', 'rlist')
-        self.assert_not_in('foo-2015-08-12-10:00', output)
-        self.assert_in('foo-2015-08-12-20:00', output)
-        self.assert_in('bar-2015-08-12-10:00', output)
-        self.assert_in('bar-2015-08-12-20:00', output)
+        self.cmd(f"--repo={self.repository_location}", "rcreate", RK_ENCRYPTION)
+        self.cmd(f"--repo={self.repository_location}", "create", "foo-2015-08-12-10:00", src_dir)
+        self.cmd(f"--repo={self.repository_location}", "create", "foo-2015-08-12-20:00", src_dir)
+        self.cmd(f"--repo={self.repository_location}", "create", "bar-2015-08-12-10:00", src_dir)
+        self.cmd(f"--repo={self.repository_location}", "create", "bar-2015-08-12-20:00", src_dir)
+        output = self.cmd(
+            f"--repo={self.repository_location}",
+            "prune",
+            "--list",
+            "--dry-run",
+            "--keep-daily=1",
+            "--glob-archives=foo-*",
+        )
+        assert re.search(r"Keeping archive \(rule: daily #1\):\s+foo-2015-08-12-20:00", output)
+        assert re.search(r"Would prune:\s+foo-2015-08-12-10:00", output)
+        output = self.cmd(f"--repo={self.repository_location}", "rlist")
+        self.assert_in("foo-2015-08-12-10:00", output)
+        self.assert_in("foo-2015-08-12-20:00", output)
+        self.assert_in("bar-2015-08-12-10:00", output)
+        self.assert_in("bar-2015-08-12-20:00", output)
+        self.cmd(f"--repo={self.repository_location}", "prune", "--keep-daily=1", "--glob-archives=foo-*")
+        output = self.cmd(f"--repo={self.repository_location}", "rlist")
+        self.assert_not_in("foo-2015-08-12-10:00", output)
+        self.assert_in("foo-2015-08-12-20:00", output)
+        self.assert_in("bar-2015-08-12-10:00", output)
+        self.assert_in("bar-2015-08-12-20:00", output)
 
     def test_prune_repository_glob(self):
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
-        self.cmd(f'--repo={self.repository_location}', 'create', '2015-08-12-10:00-foo', src_dir)
-        self.cmd(f'--repo={self.repository_location}', 'create', '2015-08-12-20:00-foo', src_dir)
-        self.cmd(f'--repo={self.repository_location}', 'create', '2015-08-12-10:00-bar', src_dir)
-        self.cmd(f'--repo={self.repository_location}', 'create', '2015-08-12-20:00-bar', src_dir)
-        output = self.cmd(f'--repo={self.repository_location}', 'prune', '--list', '--dry-run', '--keep-daily=1', '--glob-archives=2015-*-foo')
-        assert re.search(r'Keeping archive \(rule: daily #1\):\s+2015-08-12-20:00-foo', output)
-        assert re.search(r'Would prune:\s+2015-08-12-10:00-foo', output)
-        output = self.cmd(f'--repo={self.repository_location}', 'rlist')
-        self.assert_in('2015-08-12-10:00-foo', output)
-        self.assert_in('2015-08-12-20:00-foo', output)
-        self.assert_in('2015-08-12-10:00-bar', output)
-        self.assert_in('2015-08-12-20:00-bar', output)
-        self.cmd(f'--repo={self.repository_location}', 'prune', '--keep-daily=1', '--glob-archives=2015-*-foo')
-        output = self.cmd(f'--repo={self.repository_location}', 'rlist')
-        self.assert_not_in('2015-08-12-10:00-foo', output)
-        self.assert_in('2015-08-12-20:00-foo', output)
-        self.assert_in('2015-08-12-10:00-bar', output)
-        self.assert_in('2015-08-12-20:00-bar', output)
+        self.cmd(f"--repo={self.repository_location}", "rcreate", RK_ENCRYPTION)
+        self.cmd(f"--repo={self.repository_location}", "create", "2015-08-12-10:00-foo", src_dir)
+        self.cmd(f"--repo={self.repository_location}", "create", "2015-08-12-20:00-foo", src_dir)
+        self.cmd(f"--repo={self.repository_location}", "create", "2015-08-12-10:00-bar", src_dir)
+        self.cmd(f"--repo={self.repository_location}", "create", "2015-08-12-20:00-bar", src_dir)
+        output = self.cmd(
+            f"--repo={self.repository_location}",
+            "prune",
+            "--list",
+            "--dry-run",
+            "--keep-daily=1",
+            "--glob-archives=2015-*-foo",
+        )
+        assert re.search(r"Keeping archive \(rule: daily #1\):\s+2015-08-12-20:00-foo", output)
+        assert re.search(r"Would prune:\s+2015-08-12-10:00-foo", output)
+        output = self.cmd(f"--repo={self.repository_location}", "rlist")
+        self.assert_in("2015-08-12-10:00-foo", output)
+        self.assert_in("2015-08-12-20:00-foo", output)
+        self.assert_in("2015-08-12-10:00-bar", output)
+        self.assert_in("2015-08-12-20:00-bar", output)
+        self.cmd(f"--repo={self.repository_location}", "prune", "--keep-daily=1", "--glob-archives=2015-*-foo")
+        output = self.cmd(f"--repo={self.repository_location}", "rlist")
+        self.assert_not_in("2015-08-12-10:00-foo", output)
+        self.assert_in("2015-08-12-20:00-foo", output)
+        self.assert_in("2015-08-12-10:00-bar", output)
+        self.assert_in("2015-08-12-20:00-bar", output)
 
     def test_list_prefix(self):
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
-        self.cmd(f'--repo={self.repository_location}', 'create', 'test-1', src_dir)
-        self.cmd(f'--repo={self.repository_location}', 'create', 'something-else-than-test-1', src_dir)
-        self.cmd(f'--repo={self.repository_location}', 'create', 'test-2', src_dir)
-        output = self.cmd(f'--repo={self.repository_location}', 'rlist', '--glob-archives=test-*')
-        self.assert_in('test-1', output)
-        self.assert_in('test-2', output)
-        self.assert_not_in('something-else', output)
+        self.cmd(f"--repo={self.repository_location}", "rcreate", RK_ENCRYPTION)
+        self.cmd(f"--repo={self.repository_location}", "create", "test-1", src_dir)
+        self.cmd(f"--repo={self.repository_location}", "create", "something-else-than-test-1", src_dir)
+        self.cmd(f"--repo={self.repository_location}", "create", "test-2", src_dir)
+        output = self.cmd(f"--repo={self.repository_location}", "rlist", "--glob-archives=test-*")
+        self.assert_in("test-1", output)
+        self.assert_in("test-2", output)
+        self.assert_not_in("something-else", output)
 
     def test_list_format(self):
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
-        self.cmd(f'--repo={self.repository_location}', 'create', 'test', src_dir)
-        output_1 = self.cmd(f'--repo={self.repository_location}', 'list', 'test')
-        output_2 = self.cmd(f'--repo={self.repository_location}', 'list', 'test', '--format', '{mode} {user:6} {group:6} {size:8d} {mtime} {path}{extra}{NEWLINE}')
-        output_3 = self.cmd(f'--repo={self.repository_location}', 'list', 'test', '--format', '{mtime:%s} {path}{NL}')
+        self.cmd(f"--repo={self.repository_location}", "rcreate", RK_ENCRYPTION)
+        self.cmd(f"--repo={self.repository_location}", "create", "test", src_dir)
+        output_1 = self.cmd(f"--repo={self.repository_location}", "list", "test")
+        output_2 = self.cmd(
+            f"--repo={self.repository_location}",
+            "list",
+            "test",
+            "--format",
+            "{mode} {user:6} {group:6} {size:8d} {mtime} {path}{extra}{NEWLINE}",
+        )
+        output_3 = self.cmd(f"--repo={self.repository_location}", "list", "test", "--format", "{mtime:%s} {path}{NL}")
         self.assertEqual(output_1, output_2)
         self.assertNotEqual(output_1, output_3)
 
     def test_archives_format(self):
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
-        self.cmd(f'--repo={self.repository_location}', 'create', '--comment', 'comment 1', 'test-1', src_dir)
-        self.cmd(f'--repo={self.repository_location}', 'create', '--comment', 'comment 2', 'test-2', src_dir)
-        output_1 = self.cmd(f'--repo={self.repository_location}', 'rlist')
-        output_2 = self.cmd(f'--repo={self.repository_location}', 'rlist', '--format', '{archive:<36} {time} [{id}]{NL}')
+        self.cmd(f"--repo={self.repository_location}", "rcreate", RK_ENCRYPTION)
+        self.cmd(f"--repo={self.repository_location}", "create", "--comment", "comment 1", "test-1", src_dir)
+        self.cmd(f"--repo={self.repository_location}", "create", "--comment", "comment 2", "test-2", src_dir)
+        output_1 = self.cmd(f"--repo={self.repository_location}", "rlist")
+        output_2 = self.cmd(
+            f"--repo={self.repository_location}", "rlist", "--format", "{archive:<36} {time} [{id}]{NL}"
+        )
         self.assertEqual(output_1, output_2)
-        output_1 = self.cmd(f'--repo={self.repository_location}', 'rlist', '--short')
-        self.assertEqual(output_1, 'test-1\ntest-2\n')
-        output_1 = self.cmd(f'--repo={self.repository_location}', 'rlist', '--format', '{barchive}/')
-        self.assertEqual(output_1, 'test-1/test-2/')
-        output_3 = self.cmd(f'--repo={self.repository_location}', 'rlist', '--format', '{name} {comment}{NL}')
-        self.assert_in('test-1 comment 1\n', output_3)
-        self.assert_in('test-2 comment 2\n', output_3)
+        output_1 = self.cmd(f"--repo={self.repository_location}", "rlist", "--short")
+        self.assertEqual(output_1, "test-1\ntest-2\n")
+        output_1 = self.cmd(f"--repo={self.repository_location}", "rlist", "--format", "{barchive}/")
+        self.assertEqual(output_1, "test-1/test-2/")
+        output_3 = self.cmd(f"--repo={self.repository_location}", "rlist", "--format", "{name} {comment}{NL}")
+        self.assert_in("test-1 comment 1\n", output_3)
+        self.assert_in("test-2 comment 2\n", output_3)
 
     def test_list_hash(self):
-        self.create_regular_file('empty_file', size=0)
-        self.create_regular_file('amb', contents=b'a' * 1000000)
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
-        self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
-        output = self.cmd(f'--repo={self.repository_location}', 'list', 'test', '--format', '{sha256} {path}{NL}')
+        self.create_regular_file("empty_file", size=0)
+        self.create_regular_file("amb", contents=b"a" * 1000000)
+        self.cmd(f"--repo={self.repository_location}", "rcreate", RK_ENCRYPTION)
+        self.cmd(f"--repo={self.repository_location}", "create", "test", "input")
+        output = self.cmd(f"--repo={self.repository_location}", "list", "test", "--format", "{sha256} {path}{NL}")
         assert "cdc76e5c9914fb9281a1c7e284d73e67f1809a48a497200e046d39ccc7112cd0 input/amb" in output
         assert "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855 input/empty_file" in output
 
     def test_list_consider_checkpoints(self):
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
-        self.cmd(f'--repo={self.repository_location}', 'create', 'test1', src_dir)
+        self.cmd(f"--repo={self.repository_location}", "rcreate", RK_ENCRYPTION)
+        self.cmd(f"--repo={self.repository_location}", "create", "test1", src_dir)
         # these are not really a checkpoints, but they look like some:
-        self.cmd(f'--repo={self.repository_location}', 'create', 'test2.checkpoint', src_dir)
-        self.cmd(f'--repo={self.repository_location}', 'create', 'test3.checkpoint.1', src_dir)
-        output = self.cmd(f'--repo={self.repository_location}', 'rlist')
+        self.cmd(f"--repo={self.repository_location}", "create", "test2.checkpoint", src_dir)
+        self.cmd(f"--repo={self.repository_location}", "create", "test3.checkpoint.1", src_dir)
+        output = self.cmd(f"--repo={self.repository_location}", "rlist")
         assert "test1" in output
         assert "test2.checkpoint" not in output
         assert "test3.checkpoint.1" not in output
-        output = self.cmd(f'--repo={self.repository_location}', 'rlist', '--consider-checkpoints')
+        output = self.cmd(f"--repo={self.repository_location}", "rlist", "--consider-checkpoints")
         assert "test1" in output
         assert "test2.checkpoint" in output
         assert "test3.checkpoint.1" in output
 
     def test_list_chunk_counts(self):
-        self.create_regular_file('empty_file', size=0)
-        self.create_regular_file('two_chunks')
-        with open(os.path.join(self.input_path, 'two_chunks'), 'wb') as fd:
-            fd.write(b'abba' * 2000000)
-            fd.write(b'baab' * 2000000)
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
-        self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
-        output = self.cmd(f'--repo={self.repository_location}', 'list', 'test', '--format', '{num_chunks} {unique_chunks} {path}{NL}')
+        self.create_regular_file("empty_file", size=0)
+        self.create_regular_file("two_chunks")
+        with open(os.path.join(self.input_path, "two_chunks"), "wb") as fd:
+            fd.write(b"abba" * 2000000)
+            fd.write(b"baab" * 2000000)
+        self.cmd(f"--repo={self.repository_location}", "rcreate", RK_ENCRYPTION)
+        self.cmd(f"--repo={self.repository_location}", "create", "test", "input")
+        output = self.cmd(
+            f"--repo={self.repository_location}", "list", "test", "--format", "{num_chunks} {unique_chunks} {path}{NL}"
+        )
         assert "0 0 input/empty_file" in output
         assert "2 2 input/two_chunks" in output
 
     def test_list_size(self):
-        self.create_regular_file('compressible_file', size=10000)
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
-        self.cmd(f'--repo={self.repository_location}', 'create', '-C', 'lz4', 'test', 'input')
-        output = self.cmd(f'--repo={self.repository_location}', 'list', 'test', '--format', '{size} {path}{NL}')
+        self.create_regular_file("compressible_file", size=10000)
+        self.cmd(f"--repo={self.repository_location}", "rcreate", RK_ENCRYPTION)
+        self.cmd(f"--repo={self.repository_location}", "create", "-C", "lz4", "test", "input")
+        output = self.cmd(f"--repo={self.repository_location}", "list", "test", "--format", "{size} {path}{NL}")
         size, path = output.split("\n")[1].split(" ")
         assert int(size) == 10000
 
     def test_list_json(self):
-        self.create_regular_file('file1', size=1024 * 80)
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
-        self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
-        list_repo = json.loads(self.cmd(f'--repo={self.repository_location}', 'rlist', '--json'))
-        repository = list_repo['repository']
-        assert len(repository['id']) == 64
-        assert datetime.strptime(repository['last_modified'], ISO_FORMAT)  # must not raise
-        assert list_repo['encryption']['mode'] == RK_ENCRYPTION[13:]
-        assert 'keyfile' not in list_repo['encryption']
-        archive0 = list_repo['archives'][0]
-        assert datetime.strptime(archive0['time'], ISO_FORMAT)  # must not raise
+        self.create_regular_file("file1", size=1024 * 80)
+        self.cmd(f"--repo={self.repository_location}", "rcreate", RK_ENCRYPTION)
+        self.cmd(f"--repo={self.repository_location}", "create", "test", "input")
+        list_repo = json.loads(self.cmd(f"--repo={self.repository_location}", "rlist", "--json"))
+        repository = list_repo["repository"]
+        assert len(repository["id"]) == 64
+        assert datetime.strptime(repository["last_modified"], ISO_FORMAT)  # must not raise
+        assert list_repo["encryption"]["mode"] == RK_ENCRYPTION[13:]
+        assert "keyfile" not in list_repo["encryption"]
+        archive0 = list_repo["archives"][0]
+        assert datetime.strptime(archive0["time"], ISO_FORMAT)  # must not raise
 
-        list_archive = self.cmd(f'--repo={self.repository_location}', 'list', 'test', '--json-lines')
+        list_archive = self.cmd(f"--repo={self.repository_location}", "list", "test", "--json-lines")
         items = [json.loads(s) for s in list_archive.splitlines()]
         assert len(items) == 2
         file1 = items[1]
-        assert file1['path'] == 'input/file1'
-        assert file1['size'] == 81920
-        assert datetime.strptime(file1['mtime'], ISO_FORMAT)  # must not raise
+        assert file1["path"] == "input/file1"
+        assert file1["size"] == 81920
+        assert datetime.strptime(file1["mtime"], ISO_FORMAT)  # must not raise
 
-        list_archive = self.cmd(f'--repo={self.repository_location}', 'list', 'test', '--json-lines', '--format={sha256}')
+        list_archive = self.cmd(
+            f"--repo={self.repository_location}", "list", "test", "--json-lines", "--format={sha256}"
+        )
         items = [json.loads(s) for s in list_archive.splitlines()]
         assert len(items) == 2
         file1 = items[1]
-        assert file1['path'] == 'input/file1'
-        assert file1['sha256'] == 'b2915eb69f260d8d3c25249195f2c8f4f716ea82ec760ae929732c0262442b2b'
+        assert file1["path"] == "input/file1"
+        assert file1["sha256"] == "b2915eb69f260d8d3c25249195f2c8f4f716ea82ec760ae929732c0262442b2b"
 
     def test_log_json(self):
         self.create_test_files()
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
-        log = self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input', '--log-json', '--list', '--debug')
+        self.cmd(f"--repo={self.repository_location}", "rcreate", RK_ENCRYPTION)
+        log = self.cmd(
+            f"--repo={self.repository_location}", "create", "test", "input", "--log-json", "--list", "--debug"
+        )
         messages = {}  # type -> message, one of each kind
         for line in log.splitlines():
             msg = json.loads(line)
-            messages[msg['type']] = msg
+            messages[msg["type"]] = msg
 
-        file_status = messages['file_status']
-        assert 'status' in file_status
-        assert file_status['path'].startswith('input')
+        file_status = messages["file_status"]
+        assert "status" in file_status
+        assert file_status["path"].startswith("input")
 
-        log_message = messages['log_message']
-        assert isinstance(log_message['time'], float)
-        assert log_message['levelname'] == 'DEBUG'  # there should only be DEBUG messages
-        assert isinstance(log_message['message'], str)
+        log_message = messages["log_message"]
+        assert isinstance(log_message["time"], float)
+        assert log_message["levelname"] == "DEBUG"  # there should only be DEBUG messages
+        assert isinstance(log_message["message"], str)
 
     def test_debug_profile(self):
         self.create_test_files()
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
-        self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input', '--debug-profile=create.prof')
-        self.cmd('debug', 'convert-profile', 'create.prof', 'create.pyprof')
-        stats = pstats.Stats('create.pyprof')
+        self.cmd(f"--repo={self.repository_location}", "rcreate", RK_ENCRYPTION)
+        self.cmd(f"--repo={self.repository_location}", "create", "test", "input", "--debug-profile=create.prof")
+        self.cmd("debug", "convert-profile", "create.prof", "create.pyprof")
+        stats = pstats.Stats("create.pyprof")
         stats.strip_dirs()
-        stats.sort_stats('cumtime')
+        stats.sort_stats("cumtime")
 
-        self.cmd(f'--repo={self.repository_location}', 'create', 'test2', 'input', '--debug-profile=create.pyprof')
-        stats = pstats.Stats('create.pyprof')  # Only do this on trusted data!
+        self.cmd(f"--repo={self.repository_location}", "create", "test2", "input", "--debug-profile=create.pyprof")
+        stats = pstats.Stats("create.pyprof")  # Only do this on trusted data!
         stats.strip_dirs()
-        stats.sort_stats('cumtime')
+        stats.sort_stats("cumtime")
 
     def test_common_options(self):
         self.create_test_files()
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
-        log = self.cmd(f'--repo={self.repository_location}', '--debug', 'create', 'test', 'input')
-        assert 'security: read previous location' in log
+        self.cmd(f"--repo={self.repository_location}", "rcreate", RK_ENCRYPTION)
+        log = self.cmd(f"--repo={self.repository_location}", "--debug", "create", "test", "input")
+        assert "security: read previous location" in log
 
     def test_change_passphrase(self):
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
-        os.environ['BORG_NEW_PASSPHRASE'] = 'newpassphrase'
+        self.cmd(f"--repo={self.repository_location}", "rcreate", RK_ENCRYPTION)
+        os.environ["BORG_NEW_PASSPHRASE"] = "newpassphrase"
         # here we have both BORG_PASSPHRASE and BORG_NEW_PASSPHRASE set:
-        self.cmd(f'--repo={self.repository_location}', 'key', 'change-passphrase')
-        os.environ['BORG_PASSPHRASE'] = 'newpassphrase'
-        self.cmd(f'--repo={self.repository_location}', 'rlist')
+        self.cmd(f"--repo={self.repository_location}", "key", "change-passphrase")
+        os.environ["BORG_PASSPHRASE"] = "newpassphrase"
+        self.cmd(f"--repo={self.repository_location}", "rlist")
 
     def test_change_location_to_keyfile(self):
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
-        log = self.cmd(f'--repo={self.repository_location}', 'rinfo')
-        assert '(repokey' in log
-        self.cmd(f'--repo={self.repository_location}', 'key', 'change-location', 'keyfile')
-        log = self.cmd(f'--repo={self.repository_location}', 'rinfo')
-        assert '(key file' in log
+        self.cmd(f"--repo={self.repository_location}", "rcreate", RK_ENCRYPTION)
+        log = self.cmd(f"--repo={self.repository_location}", "rinfo")
+        assert "(repokey" in log
+        self.cmd(f"--repo={self.repository_location}", "key", "change-location", "keyfile")
+        log = self.cmd(f"--repo={self.repository_location}", "rinfo")
+        assert "(key file" in log
 
     def test_change_location_to_b2keyfile(self):
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=repokey-blake2-aes-ocb')
-        log = self.cmd(f'--repo={self.repository_location}', 'rinfo')
-        assert '(repokey BLAKE2b' in log
-        self.cmd(f'--repo={self.repository_location}', 'key', 'change-location', 'keyfile')
-        log = self.cmd(f'--repo={self.repository_location}', 'rinfo')
-        assert '(key file BLAKE2b' in log
+        self.cmd(f"--repo={self.repository_location}", "rcreate", "--encryption=repokey-blake2-aes-ocb")
+        log = self.cmd(f"--repo={self.repository_location}", "rinfo")
+        assert "(repokey BLAKE2b" in log
+        self.cmd(f"--repo={self.repository_location}", "key", "change-location", "keyfile")
+        log = self.cmd(f"--repo={self.repository_location}", "rinfo")
+        assert "(key file BLAKE2b" in log
 
     def test_change_location_to_repokey(self):
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', KF_ENCRYPTION)
-        log = self.cmd(f'--repo={self.repository_location}', 'rinfo')
-        assert '(key file' in log
-        self.cmd(f'--repo={self.repository_location}', 'key', 'change-location', 'repokey')
-        log = self.cmd(f'--repo={self.repository_location}', 'rinfo')
-        assert '(repokey' in log
+        self.cmd(f"--repo={self.repository_location}", "rcreate", KF_ENCRYPTION)
+        log = self.cmd(f"--repo={self.repository_location}", "rinfo")
+        assert "(key file" in log
+        self.cmd(f"--repo={self.repository_location}", "key", "change-location", "repokey")
+        log = self.cmd(f"--repo={self.repository_location}", "rinfo")
+        assert "(repokey" in log
 
     def test_change_location_to_b2repokey(self):
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=keyfile-blake2-aes-ocb')
-        log = self.cmd(f'--repo={self.repository_location}', 'rinfo')
-        assert '(key file BLAKE2b' in log
-        self.cmd(f'--repo={self.repository_location}', 'key', 'change-location', 'repokey')
-        log = self.cmd(f'--repo={self.repository_location}', 'rinfo')
-        assert '(repokey BLAKE2b' in log
+        self.cmd(f"--repo={self.repository_location}", "rcreate", "--encryption=keyfile-blake2-aes-ocb")
+        log = self.cmd(f"--repo={self.repository_location}", "rinfo")
+        assert "(key file BLAKE2b" in log
+        self.cmd(f"--repo={self.repository_location}", "key", "change-location", "repokey")
+        log = self.cmd(f"--repo={self.repository_location}", "rinfo")
+        assert "(repokey BLAKE2b" in log
 
     def test_break_lock(self):
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
-        self.cmd(f'--repo={self.repository_location}', 'break-lock')
+        self.cmd(f"--repo={self.repository_location}", "rcreate", RK_ENCRYPTION)
+        self.cmd(f"--repo={self.repository_location}", "break-lock")
 
     def test_usage(self):
         self.cmd()
-        self.cmd('-h')
+        self.cmd("-h")
 
     def test_help(self):
-        assert 'Borg' in self.cmd('help')
-        assert 'patterns' in self.cmd('help', 'patterns')
-        assert 'creates a new, empty repository' in self.cmd('help', 'rcreate')
-        assert 'positional arguments' not in self.cmd('help', 'rcreate', '--epilog-only')
-        assert 'creates a new, empty repository' not in self.cmd('help', 'rcreate', '--usage-only')
+        assert "Borg" in self.cmd("help")
+        assert "patterns" in self.cmd("help", "patterns")
+        assert "creates a new, empty repository" in self.cmd("help", "rcreate")
+        assert "positional arguments" not in self.cmd("help", "rcreate", "--epilog-only")
+        assert "creates a new, empty repository" not in self.cmd("help", "rcreate", "--usage-only")
 
-    @unittest.skipUnless(llfuse, 'llfuse not installed')
+    @unittest.skipUnless(llfuse, "llfuse not installed")
     def test_fuse(self):
         def has_noatime(some_file):
             atime_before = os.stat(some_file).st_atime_ns
@@ -2505,29 +2708,32 @@ class ArchiverTestCase(ArchiverTestCaseBase):
                 noatime_used = flags_noatime != flags_normal
                 return noatime_used and atime_before == atime_after
 
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
+        self.cmd(f"--repo={self.repository_location}", "rcreate", RK_ENCRYPTION)
         self.create_test_files()
-        have_noatime = has_noatime('input/file1')
-        self.cmd(f'--repo={self.repository_location}', 'create', '--exclude-nodump', '--atime', 'archive', 'input')
-        self.cmd(f'--repo={self.repository_location}', 'create', '--exclude-nodump', '--atime', 'archive2', 'input')
+        have_noatime = has_noatime("input/file1")
+        self.cmd(f"--repo={self.repository_location}", "create", "--exclude-nodump", "--atime", "archive", "input")
+        self.cmd(f"--repo={self.repository_location}", "create", "--exclude-nodump", "--atime", "archive2", "input")
         if has_lchflags:
             # remove the file we did not backup, so input and output become equal
-            os.remove(os.path.join('input', 'flagfile'))
-        mountpoint = os.path.join(self.tmpdir, 'mountpoint')
+            os.remove(os.path.join("input", "flagfile"))
+        mountpoint = os.path.join(self.tmpdir, "mountpoint")
         # mount the whole repository, archive contents shall show up in archivename subdirs of mountpoint:
         with self.fuse_mount(self.repository_location, mountpoint):
             # flags are not supported by the FUSE mount
             # we also ignore xattrs here, they are tested separately
-            self.assert_dirs_equal(self.input_path, os.path.join(mountpoint, 'archive', 'input'),
-                                   ignore_flags=True, ignore_xattrs=True)
-            self.assert_dirs_equal(self.input_path, os.path.join(mountpoint, 'archive2', 'input'),
-                                   ignore_flags=True, ignore_xattrs=True)
-        with self.fuse_mount(self.repository_location, mountpoint, '-a', 'archive'):
-            self.assert_dirs_equal(self.input_path, os.path.join(mountpoint, 'archive', 'input'),
-                                   ignore_flags=True, ignore_xattrs=True)
+            self.assert_dirs_equal(
+                self.input_path, os.path.join(mountpoint, "archive", "input"), ignore_flags=True, ignore_xattrs=True
+            )
+            self.assert_dirs_equal(
+                self.input_path, os.path.join(mountpoint, "archive2", "input"), ignore_flags=True, ignore_xattrs=True
+            )
+        with self.fuse_mount(self.repository_location, mountpoint, "-a", "archive"):
+            self.assert_dirs_equal(
+                self.input_path, os.path.join(mountpoint, "archive", "input"), ignore_flags=True, ignore_xattrs=True
+            )
             # regular file
-            in_fn = 'input/file1'
-            out_fn = os.path.join(mountpoint, 'archive', 'input', 'file1')
+            in_fn = "input/file1"
+            out_fn = os.path.join(mountpoint, "archive", "input", "file1")
             # stat
             sti1 = os.stat(in_fn)
             sto1 = os.stat(out_fn)
@@ -2543,135 +2749,135 @@ class ArchiverTestCase(ArchiverTestCaseBase):
                 # note: there is another hardlink to this, see below
                 assert sti1.st_nlink == sto1.st_nlink == 2
             # read
-            with open(in_fn, 'rb') as in_f, open(out_fn, 'rb') as out_f:
+            with open(in_fn, "rb") as in_f, open(out_fn, "rb") as out_f:
                 assert in_f.read() == out_f.read()
             # hardlink (to 'input/file1')
             if are_hardlinks_supported():
-                in_fn = 'input/hardlink'
-                out_fn = os.path.join(mountpoint, 'archive', 'input', 'hardlink')
+                in_fn = "input/hardlink"
+                out_fn = os.path.join(mountpoint, "archive", "input", "hardlink")
                 sti2 = os.stat(in_fn)
                 sto2 = os.stat(out_fn)
                 assert sti2.st_nlink == sto2.st_nlink == 2
                 assert sto1.st_ino == sto2.st_ino
             # symlink
             if are_symlinks_supported():
-                in_fn = 'input/link1'
-                out_fn = os.path.join(mountpoint, 'archive', 'input', 'link1')
+                in_fn = "input/link1"
+                out_fn = os.path.join(mountpoint, "archive", "input", "link1")
                 sti = os.stat(in_fn, follow_symlinks=False)
                 sto = os.stat(out_fn, follow_symlinks=False)
-                assert sti.st_size == len('somewhere')
-                assert sto.st_size == len('somewhere')
+                assert sti.st_size == len("somewhere")
+                assert sto.st_size == len("somewhere")
                 assert stat.S_ISLNK(sti.st_mode)
                 assert stat.S_ISLNK(sto.st_mode)
                 assert os.readlink(in_fn) == os.readlink(out_fn)
             # FIFO
             if are_fifos_supported():
-                out_fn = os.path.join(mountpoint, 'archive', 'input', 'fifo1')
+                out_fn = os.path.join(mountpoint, "archive", "input", "fifo1")
                 sto = os.stat(out_fn)
                 assert stat.S_ISFIFO(sto.st_mode)
             # list/read xattrs
             try:
-                in_fn = 'input/fusexattr'
-                out_fn = os.fsencode(os.path.join(mountpoint, 'archive', 'input', 'fusexattr'))
+                in_fn = "input/fusexattr"
+                out_fn = os.fsencode(os.path.join(mountpoint, "archive", "input", "fusexattr"))
                 if not xattr.XATTR_FAKEROOT and xattr.is_enabled(self.input_path):
-                    assert sorted(no_selinux(xattr.listxattr(out_fn))) == [b'user.empty', b'user.foo', ]
-                    assert xattr.getxattr(out_fn, b'user.foo') == b'bar'
-                    assert xattr.getxattr(out_fn, b'user.empty') == b''
+                    assert sorted(no_selinux(xattr.listxattr(out_fn))) == [b"user.empty", b"user.foo"]
+                    assert xattr.getxattr(out_fn, b"user.foo") == b"bar"
+                    assert xattr.getxattr(out_fn, b"user.empty") == b""
                 else:
                     assert no_selinux(xattr.listxattr(out_fn)) == []
                     try:
-                        xattr.getxattr(out_fn, b'user.foo')
+                        xattr.getxattr(out_fn, b"user.foo")
                     except OSError as e:
                         assert e.errno == llfuse.ENOATTR
                     else:
                         assert False, "expected OSError(ENOATTR), but no error was raised"
             except OSError as err:
-                if sys.platform.startswith(('nothing_here_now', )) and err.errno == errno.ENOTSUP:
+                if sys.platform.startswith(("nothing_here_now",)) and err.errno == errno.ENOTSUP:
                     # some systems have no xattr support on FUSE
                     pass
                 else:
                     raise
 
-    @unittest.skipUnless(llfuse, 'llfuse not installed')
+    @unittest.skipUnless(llfuse, "llfuse not installed")
     def test_fuse_versions_view(self):
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
-        self.create_regular_file('test', contents=b'first')
+        self.cmd(f"--repo={self.repository_location}", "rcreate", RK_ENCRYPTION)
+        self.create_regular_file("test", contents=b"first")
         if are_hardlinks_supported():
-            self.create_regular_file('hardlink1', contents=b'123456')
-            os.link('input/hardlink1', 'input/hardlink2')
-            os.link('input/hardlink1', 'input/hardlink3')
-        self.cmd(f'--repo={self.repository_location}', 'create', 'archive1', 'input')
-        self.create_regular_file('test', contents=b'second')
-        self.cmd(f'--repo={self.repository_location}', 'create', 'archive2', 'input')
-        mountpoint = os.path.join(self.tmpdir, 'mountpoint')
+            self.create_regular_file("hardlink1", contents=b"123456")
+            os.link("input/hardlink1", "input/hardlink2")
+            os.link("input/hardlink1", "input/hardlink3")
+        self.cmd(f"--repo={self.repository_location}", "create", "archive1", "input")
+        self.create_regular_file("test", contents=b"second")
+        self.cmd(f"--repo={self.repository_location}", "create", "archive2", "input")
+        mountpoint = os.path.join(self.tmpdir, "mountpoint")
         # mount the whole repository, archive contents shall show up in versioned view:
-        with self.fuse_mount(self.repository_location, mountpoint, '-o', 'versions'):
-            path = os.path.join(mountpoint, 'input', 'test')  # filename shows up as directory ...
+        with self.fuse_mount(self.repository_location, mountpoint, "-o", "versions"):
+            path = os.path.join(mountpoint, "input", "test")  # filename shows up as directory ...
             files = os.listdir(path)
-            assert all(f.startswith('test.') for f in files)  # ... with files test.xxxxx in there
-            assert {b'first', b'second'} == {open(os.path.join(path, f), 'rb').read() for f in files}
+            assert all(f.startswith("test.") for f in files)  # ... with files test.xxxxx in there
+            assert {b"first", b"second"} == {open(os.path.join(path, f), "rb").read() for f in files}
             if are_hardlinks_supported():
-                hl1 = os.path.join(mountpoint, 'input', 'hardlink1', 'hardlink1.00001')
-                hl2 = os.path.join(mountpoint, 'input', 'hardlink2', 'hardlink2.00001')
-                hl3 = os.path.join(mountpoint, 'input', 'hardlink3', 'hardlink3.00001')
+                hl1 = os.path.join(mountpoint, "input", "hardlink1", "hardlink1.00001")
+                hl2 = os.path.join(mountpoint, "input", "hardlink2", "hardlink2.00001")
+                hl3 = os.path.join(mountpoint, "input", "hardlink3", "hardlink3.00001")
                 assert os.stat(hl1).st_ino == os.stat(hl2).st_ino == os.stat(hl3).st_ino
-                assert open(hl3, 'rb').read() == b'123456'
+                assert open(hl3, "rb").read() == b"123456"
         # similar again, but exclude the 1st hardlink:
-        with self.fuse_mount(self.repository_location, mountpoint, '-o', 'versions', '-e', 'input/hardlink1'):
+        with self.fuse_mount(self.repository_location, mountpoint, "-o", "versions", "-e", "input/hardlink1"):
             if are_hardlinks_supported():
-                hl2 = os.path.join(mountpoint, 'input', 'hardlink2', 'hardlink2.00001')
-                hl3 = os.path.join(mountpoint, 'input', 'hardlink3', 'hardlink3.00001')
+                hl2 = os.path.join(mountpoint, "input", "hardlink2", "hardlink2.00001")
+                hl3 = os.path.join(mountpoint, "input", "hardlink3", "hardlink3.00001")
                 assert os.stat(hl2).st_ino == os.stat(hl3).st_ino
-                assert open(hl3, 'rb').read() == b'123456'
+                assert open(hl3, "rb").read() == b"123456"
 
-    @unittest.skipUnless(llfuse, 'llfuse not installed')
+    @unittest.skipUnless(llfuse, "llfuse not installed")
     def test_fuse_allow_damaged_files(self):
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
-        self.create_src_archive('archive')
+        self.cmd(f"--repo={self.repository_location}", "rcreate", RK_ENCRYPTION)
+        self.create_src_archive("archive")
         # Get rid of a chunk and repair it
-        archive, repository = self.open_archive('archive')
+        archive, repository = self.open_archive("archive")
         with repository:
             for item in archive.iter_items():
-                if item.path.endswith('testsuite/archiver.py'):
+                if item.path.endswith("testsuite/archiver.py"):
                     repository.delete(item.chunks[-1].id)
                     path = item.path  # store full path for later
                     break
             else:
                 assert False  # missed the file
             repository.commit(compact=False)
-        self.cmd(f'--repo={self.repository_location}', 'check', '--repair', exit_code=0)
+        self.cmd(f"--repo={self.repository_location}", "check", "--repair", exit_code=0)
 
-        mountpoint = os.path.join(self.tmpdir, 'mountpoint')
-        with self.fuse_mount(self.repository_location, mountpoint, '-a', 'archive'):
+        mountpoint = os.path.join(self.tmpdir, "mountpoint")
+        with self.fuse_mount(self.repository_location, mountpoint, "-a", "archive"):
             with pytest.raises(OSError) as excinfo:
-                open(os.path.join(mountpoint, 'archive', path))
+                open(os.path.join(mountpoint, "archive", path))
             assert excinfo.value.errno == errno.EIO
-        with self.fuse_mount(self.repository_location, mountpoint, '-a', 'archive', '-o', 'allow_damaged_files'):
-            open(os.path.join(mountpoint, 'archive', path)).close()
+        with self.fuse_mount(self.repository_location, mountpoint, "-a", "archive", "-o", "allow_damaged_files"):
+            open(os.path.join(mountpoint, "archive", path)).close()
 
-    @unittest.skipUnless(llfuse, 'llfuse not installed')
+    @unittest.skipUnless(llfuse, "llfuse not installed")
     def test_fuse_mount_options(self):
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
-        self.create_src_archive('arch11')
-        self.create_src_archive('arch12')
-        self.create_src_archive('arch21')
-        self.create_src_archive('arch22')
+        self.cmd(f"--repo={self.repository_location}", "rcreate", RK_ENCRYPTION)
+        self.create_src_archive("arch11")
+        self.create_src_archive("arch12")
+        self.create_src_archive("arch21")
+        self.create_src_archive("arch22")
 
-        mountpoint = os.path.join(self.tmpdir, 'mountpoint')
-        with self.fuse_mount(self.repository_location, mountpoint, '--first=2', '--sort=name'):
-            assert sorted(os.listdir(os.path.join(mountpoint))) == ['arch11', 'arch12']
-        with self.fuse_mount(self.repository_location, mountpoint, '--last=2', '--sort=name'):
-            assert sorted(os.listdir(os.path.join(mountpoint))) == ['arch21', 'arch22']
-        with self.fuse_mount(self.repository_location, mountpoint, '--glob-archives=arch1*'):
-            assert sorted(os.listdir(os.path.join(mountpoint))) == ['arch11', 'arch12']
-        with self.fuse_mount(self.repository_location, mountpoint, '--glob-archives=arch2*'):
-            assert sorted(os.listdir(os.path.join(mountpoint))) == ['arch21', 'arch22']
-        with self.fuse_mount(self.repository_location, mountpoint, '--glob-archives=arch*'):
-            assert sorted(os.listdir(os.path.join(mountpoint))) == ['arch11', 'arch12', 'arch21', 'arch22']
-        with self.fuse_mount(self.repository_location, mountpoint, '--glob-archives=nope'):
+        mountpoint = os.path.join(self.tmpdir, "mountpoint")
+        with self.fuse_mount(self.repository_location, mountpoint, "--first=2", "--sort=name"):
+            assert sorted(os.listdir(os.path.join(mountpoint))) == ["arch11", "arch12"]
+        with self.fuse_mount(self.repository_location, mountpoint, "--last=2", "--sort=name"):
+            assert sorted(os.listdir(os.path.join(mountpoint))) == ["arch21", "arch22"]
+        with self.fuse_mount(self.repository_location, mountpoint, "--glob-archives=arch1*"):
+            assert sorted(os.listdir(os.path.join(mountpoint))) == ["arch11", "arch12"]
+        with self.fuse_mount(self.repository_location, mountpoint, "--glob-archives=arch2*"):
+            assert sorted(os.listdir(os.path.join(mountpoint))) == ["arch21", "arch22"]
+        with self.fuse_mount(self.repository_location, mountpoint, "--glob-archives=arch*"):
+            assert sorted(os.listdir(os.path.join(mountpoint))) == ["arch11", "arch12", "arch21", "arch22"]
+        with self.fuse_mount(self.repository_location, mountpoint, "--glob-archives=nope"):
             assert sorted(os.listdir(os.path.join(mountpoint))) == []
 
-    @unittest.skipUnless(llfuse, 'llfuse not installed')
+    @unittest.skipUnless(llfuse, "llfuse not installed")
     def test_migrate_lock_alive(self):
         """Both old_id and new_id must not be stale during lock migration / daemonization."""
         from functools import wraps
@@ -2680,7 +2886,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
 
         # Check results are communicated from the borg mount background process
         # to the pytest process by means of a serialized dict object stored in this file.
-        assert_data_file = os.path.join(self.tmpdir, 'migrate_lock_assert_data.pickle')
+        assert_data_file = os.path.join(self.tmpdir, "migrate_lock_assert_data.pickle")
 
         # Decorates Lock.migrate_lock() with process_alive() checks before and after.
         # (We don't want to mix testing code into runtime.)
@@ -2689,144 +2895,160 @@ class ArchiverTestCase(ArchiverTestCaseBase):
             def wrapper(self, old_id, new_id):
                 wrapper.num_calls += 1
                 assert_data = {
-                    'num_calls': wrapper.num_calls,
-                    'old_id': old_id,
-                    'new_id': new_id,
-                    'before': {
-                        'old_id_alive': platform.process_alive(*old_id),
-                        'new_id_alive': platform.process_alive(*new_id)},
-                    'exception': None,
-                    'exception.extr_tb': None,
-                    'after': {
-                        'old_id_alive': None,
-                        'new_id_alive': None}}
+                    "num_calls": wrapper.num_calls,
+                    "old_id": old_id,
+                    "new_id": new_id,
+                    "before": {
+                        "old_id_alive": platform.process_alive(*old_id),
+                        "new_id_alive": platform.process_alive(*new_id),
+                    },
+                    "exception": None,
+                    "exception.extr_tb": None,
+                    "after": {"old_id_alive": None, "new_id_alive": None},
+                }
                 try:
-                    with open(assert_data_file, 'wb') as _out:
+                    with open(assert_data_file, "wb") as _out:
                         pickle.dump(assert_data, _out)
                 except:
                     pass
                 try:
                     return migrate_lock(self, old_id, new_id)
                 except BaseException as e:
-                    assert_data['exception'] = e
-                    assert_data['exception.extr_tb'] = traceback.extract_tb(e.__traceback__)
+                    assert_data["exception"] = e
+                    assert_data["exception.extr_tb"] = traceback.extract_tb(e.__traceback__)
                 finally:
-                    assert_data['after'].update({
-                        'old_id_alive': platform.process_alive(*old_id),
-                        'new_id_alive': platform.process_alive(*new_id)})
+                    assert_data["after"].update(
+                        {
+                            "old_id_alive": platform.process_alive(*old_id),
+                            "new_id_alive": platform.process_alive(*new_id),
+                        }
+                    )
                     try:
-                        with open(assert_data_file, 'wb') as _out:
+                        with open(assert_data_file, "wb") as _out:
                             pickle.dump(assert_data, _out)
                     except:
                         pass
+
             wrapper.num_calls = 0
             return wrapper
 
         # Decorate
         borg.locking.Lock.migrate_lock = write_assert_data(borg.locking.Lock.migrate_lock)
         try:
-            self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=none')
-            self.create_src_archive('arch')
-            mountpoint = os.path.join(self.tmpdir, 'mountpoint')
+            self.cmd(f"--repo={self.repository_location}", "rcreate", "--encryption=none")
+            self.create_src_archive("arch")
+            mountpoint = os.path.join(self.tmpdir, "mountpoint")
             # In order that the decoration is kept for the borg mount process, we must not spawn, but actually fork;
             # not to be confused with the forking in borg.helpers.daemonize() which is done as well.
             with self.fuse_mount(self.repository_location, mountpoint, os_fork=True):
                 pass
-            with open(assert_data_file, 'rb') as _in:
+            with open(assert_data_file, "rb") as _in:
                 assert_data = pickle.load(_in)
-            print(f'\nLock.migrate_lock(): assert_data = {assert_data!r}.', file=sys.stderr, flush=True)
-            exception = assert_data['exception']
+            print(f"\nLock.migrate_lock(): assert_data = {assert_data!r}.", file=sys.stderr, flush=True)
+            exception = assert_data["exception"]
             if exception is not None:
-                extracted_tb = assert_data['exception.extr_tb']
+                extracted_tb = assert_data["exception.extr_tb"]
                 print(
-                    'Lock.migrate_lock() raised an exception:\n',
-                    'Traceback (most recent call last):\n',
+                    "Lock.migrate_lock() raised an exception:\n",
+                    "Traceback (most recent call last):\n",
                     *traceback.format_list(extracted_tb),
                     *traceback.format_exception(exception.__class__, exception, None),
-                    sep='', end='', file=sys.stderr, flush=True)
+                    sep="",
+                    end="",
+                    file=sys.stderr,
+                    flush=True,
+                )
 
-            assert assert_data['num_calls'] == 1, "Lock.migrate_lock() must be called exactly once."
+            assert assert_data["num_calls"] == 1, "Lock.migrate_lock() must be called exactly once."
             assert exception is None, "Lock.migrate_lock() may not raise an exception."
 
-            assert_data_before = assert_data['before']
-            assert assert_data_before['old_id_alive'], "old_id must be alive (=must not be stale) when calling Lock.migrate_lock()."
-            assert assert_data_before['new_id_alive'], "new_id must be alive (=must not be stale) when calling Lock.migrate_lock()."
+            assert_data_before = assert_data["before"]
+            assert assert_data_before[
+                "old_id_alive"
+            ], "old_id must be alive (=must not be stale) when calling Lock.migrate_lock()."
+            assert assert_data_before[
+                "new_id_alive"
+            ], "new_id must be alive (=must not be stale) when calling Lock.migrate_lock()."
 
-            assert_data_after = assert_data['after']
-            assert assert_data_after['old_id_alive'], "old_id must be alive (=must not be stale) when Lock.migrate_lock() has returned."
-            assert assert_data_after['new_id_alive'], "new_id must be alive (=must not be stale) when Lock.migrate_lock() has returned."
+            assert_data_after = assert_data["after"]
+            assert assert_data_after[
+                "old_id_alive"
+            ], "old_id must be alive (=must not be stale) when Lock.migrate_lock() has returned."
+            assert assert_data_after[
+                "new_id_alive"
+            ], "new_id must be alive (=must not be stale) when Lock.migrate_lock() has returned."
         finally:
             # Undecorate
             borg.locking.Lock.migrate_lock = borg.locking.Lock.migrate_lock.__wrapped__
 
     def test_debug_dump_archive_items(self):
         self.create_test_files()
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
-        self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
-        with changedir('output'):
-            output = self.cmd(f'--repo={self.repository_location}', 'debug', 'dump-archive-items', 'test')
-        output_dir = sorted(os.listdir('output'))
-        assert len(output_dir) > 0 and output_dir[0].startswith('000000_')
-        assert 'Done.' in output
+        self.cmd(f"--repo={self.repository_location}", "rcreate", RK_ENCRYPTION)
+        self.cmd(f"--repo={self.repository_location}", "create", "test", "input")
+        with changedir("output"):
+            output = self.cmd(f"--repo={self.repository_location}", "debug", "dump-archive-items", "test")
+        output_dir = sorted(os.listdir("output"))
+        assert len(output_dir) > 0 and output_dir[0].startswith("000000_")
+        assert "Done." in output
 
     def test_debug_dump_repo_objs(self):
         self.create_test_files()
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
-        self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
-        with changedir('output'):
-            output = self.cmd(f'--repo={self.repository_location}', 'debug', 'dump-repo-objs')
-        output_dir = sorted(os.listdir('output'))
-        assert len(output_dir) > 0 and output_dir[0].startswith('00000000_')
-        assert 'Done.' in output
+        self.cmd(f"--repo={self.repository_location}", "rcreate", RK_ENCRYPTION)
+        self.cmd(f"--repo={self.repository_location}", "create", "test", "input")
+        with changedir("output"):
+            output = self.cmd(f"--repo={self.repository_location}", "debug", "dump-repo-objs")
+        output_dir = sorted(os.listdir("output"))
+        assert len(output_dir) > 0 and output_dir[0].startswith("00000000_")
+        assert "Done." in output
 
     def test_debug_put_get_delete_obj(self):
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
-        data = b'some data'
+        self.cmd(f"--repo={self.repository_location}", "rcreate", RK_ENCRYPTION)
+        data = b"some data"
         hexkey = sha256(data).hexdigest()
-        self.create_regular_file('file', contents=data)
-        output = self.cmd(f'--repo={self.repository_location}', 'debug', 'put-obj', 'input/file')
+        self.create_regular_file("file", contents=data)
+        output = self.cmd(f"--repo={self.repository_location}", "debug", "put-obj", "input/file")
         assert hexkey in output
-        output = self.cmd(f'--repo={self.repository_location}', 'debug', 'get-obj', hexkey, 'output/file')
+        output = self.cmd(f"--repo={self.repository_location}", "debug", "get-obj", hexkey, "output/file")
         assert hexkey in output
-        with open('output/file', 'rb') as f:
+        with open("output/file", "rb") as f:
             data_read = f.read()
         assert data == data_read
-        output = self.cmd(f'--repo={self.repository_location}', 'debug', 'delete-obj', hexkey)
+        output = self.cmd(f"--repo={self.repository_location}", "debug", "delete-obj", hexkey)
         assert "deleted" in output
-        output = self.cmd(f'--repo={self.repository_location}', 'debug', 'delete-obj', hexkey)
+        output = self.cmd(f"--repo={self.repository_location}", "debug", "delete-obj", hexkey)
         assert "not found" in output
-        output = self.cmd(f'--repo={self.repository_location}', 'debug', 'delete-obj', 'invalid')
+        output = self.cmd(f"--repo={self.repository_location}", "debug", "delete-obj", "invalid")
         assert "is invalid" in output
 
     def test_init_interrupt(self):
         def raise_eof(*args, **kwargs):
             raise EOFError
 
-        with patch.object(FlexiKey, 'create', raise_eof):
-            self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION, exit_code=1)
+        with patch.object(FlexiKey, "create", raise_eof):
+            self.cmd(f"--repo={self.repository_location}", "rcreate", RK_ENCRYPTION, exit_code=1)
         assert not os.path.exists(self.repository_location)
 
     def test_init_requires_encryption_option(self):
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', exit_code=2)
+        self.cmd(f"--repo={self.repository_location}", "rcreate", exit_code=2)
 
     def test_init_nested_repositories(self):
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
+        self.cmd(f"--repo={self.repository_location}", "rcreate", RK_ENCRYPTION)
         if self.FORK_DEFAULT:
-            self.cmd(f'--repo={self.repository_location}/nested', 'rcreate', RK_ENCRYPTION, exit_code=2)
+            self.cmd(f"--repo={self.repository_location}/nested", "rcreate", RK_ENCRYPTION, exit_code=2)
         else:
             with pytest.raises(Repository.AlreadyExists):
-                self.cmd(f'--repo={self.repository_location}/nested', 'rcreate', RK_ENCRYPTION)
+                self.cmd(f"--repo={self.repository_location}/nested", "rcreate", RK_ENCRYPTION)
 
     def test_init_refuse_to_overwrite_keyfile(self):
         """BORG_KEY_FILE=something borg init should quit if "something" already exists.
 
         See https://github.com/borgbackup/borg/pull/6046"""
-        keyfile = os.path.join(self.tmpdir, 'keyfile')
+        keyfile = os.path.join(self.tmpdir, "keyfile")
         with environment_variable(BORG_KEY_FILE=keyfile):
-            self.cmd(f'--repo={self.repository_location}0', 'rcreate', KF_ENCRYPTION)
+            self.cmd(f"--repo={self.repository_location}0", "rcreate", KF_ENCRYPTION)
             with open(keyfile) as file:
                 before = file.read()
-            arg = (f'--repo={self.repository_location}1', 'rcreate', KF_ENCRYPTION)
+            arg = (f"--repo={self.repository_location}1", "rcreate", KF_ENCRYPTION)
             if self.FORK_DEFAULT:
                 self.cmd(*arg, exit_code=2)
             else:
@@ -2838,7 +3060,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
 
     def check_cache(self):
         # First run a regular borg check
-        self.cmd(f'--repo={self.repository_location}', 'check')
+        self.cmd(f"--repo={self.repository_location}", "check")
         # Then check that the cache on disk matches exactly what's in the repo.
         with self.open_repository() as repository:
             manifest, key = Manifest.load(repository, Manifest.NO_OPERATION_CHECK)
@@ -2858,8 +3080,8 @@ class ArchiverTestCase(ArchiverTestCaseBase):
             assert id in seen
 
     def test_check_cache(self):
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
-        self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
+        self.cmd(f"--repo={self.repository_location}", "rcreate", RK_ENCRYPTION)
+        self.cmd(f"--repo={self.repository_location}", "create", "test", "input")
         with self.open_repository() as repository:
             manifest, key = Manifest.load(repository, Manifest.NO_OPERATION_CHECK)
             with Cache(repository, key, manifest, sync=False) as cache:
@@ -2870,177 +3092,206 @@ class ArchiverTestCase(ArchiverTestCaseBase):
             self.check_cache()
 
     def test_recreate_target_rc(self):
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
-        output = self.cmd(f'--repo={self.repository_location}', 'recreate', '--target=asdf', exit_code=2)
-        assert 'Need to specify single archive' in output
+        self.cmd(f"--repo={self.repository_location}", "rcreate", RK_ENCRYPTION)
+        output = self.cmd(f"--repo={self.repository_location}", "recreate", "--target=asdf", exit_code=2)
+        assert "Need to specify single archive" in output
 
     def test_recreate_target(self):
         self.create_test_files()
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
+        self.cmd(f"--repo={self.repository_location}", "rcreate", RK_ENCRYPTION)
         self.check_cache()
-        self.cmd(f'--repo={self.repository_location}', 'create', 'test0', 'input')
+        self.cmd(f"--repo={self.repository_location}", "create", "test0", "input")
         self.check_cache()
-        original_archive = self.cmd(f'--repo={self.repository_location}', 'rlist')
-        self.cmd(f'--repo={self.repository_location}', 'recreate', 'test0', 'input/dir2',
-                 '-e', 'input/dir2/file3', '--target=new-archive')
+        original_archive = self.cmd(f"--repo={self.repository_location}", "rlist")
+        self.cmd(
+            f"--repo={self.repository_location}",
+            "recreate",
+            "test0",
+            "input/dir2",
+            "-e",
+            "input/dir2/file3",
+            "--target=new-archive",
+        )
         self.check_cache()
-        archives = self.cmd(f'--repo={self.repository_location}', 'rlist')
+        archives = self.cmd(f"--repo={self.repository_location}", "rlist")
         assert original_archive in archives
-        assert 'new-archive' in archives
+        assert "new-archive" in archives
 
-        listing = self.cmd(f'--repo={self.repository_location}', 'list', 'new-archive', '--short')
-        assert 'file1' not in listing
-        assert 'dir2/file2' in listing
-        assert 'dir2/file3' not in listing
+        listing = self.cmd(f"--repo={self.repository_location}", "list", "new-archive", "--short")
+        assert "file1" not in listing
+        assert "dir2/file2" in listing
+        assert "dir2/file3" not in listing
 
     def test_recreate_basic(self):
         self.create_test_files()
-        self.create_regular_file('dir2/file3', size=1024 * 80)
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
-        self.cmd(f'--repo={self.repository_location}', 'create', 'test0', 'input')
-        self.cmd(f'--repo={self.repository_location}', 'recreate', 'test0', 'input/dir2', '-e', 'input/dir2/file3')
+        self.create_regular_file("dir2/file3", size=1024 * 80)
+        self.cmd(f"--repo={self.repository_location}", "rcreate", RK_ENCRYPTION)
+        self.cmd(f"--repo={self.repository_location}", "create", "test0", "input")
+        self.cmd(f"--repo={self.repository_location}", "recreate", "test0", "input/dir2", "-e", "input/dir2/file3")
         self.check_cache()
-        listing = self.cmd(f'--repo={self.repository_location}', 'list', 'test0', '--short')
-        assert 'file1' not in listing
-        assert 'dir2/file2' in listing
-        assert 'dir2/file3' not in listing
+        listing = self.cmd(f"--repo={self.repository_location}", "list", "test0", "--short")
+        assert "file1" not in listing
+        assert "dir2/file2" in listing
+        assert "dir2/file3" not in listing
 
-    @pytest.mark.skipif(not are_hardlinks_supported(), reason='hardlinks not supported')
+    @pytest.mark.skipif(not are_hardlinks_supported(), reason="hardlinks not supported")
     def test_recreate_subtree_hardlinks(self):
         # This is essentially the same problem set as in test_extract_hardlinks
         self._extract_hardlinks_setup()
-        self.cmd(f'--repo={self.repository_location}', 'create', 'test2', 'input')
-        self.cmd(f'--repo={self.repository_location}', 'recreate', '-a', 'test', 'input/dir1')
+        self.cmd(f"--repo={self.repository_location}", "create", "test2", "input")
+        self.cmd(f"--repo={self.repository_location}", "recreate", "-a", "test", "input/dir1")
         self.check_cache()
-        with changedir('output'):
-            self.cmd(f'--repo={self.repository_location}', 'extract', 'test')
-            assert os.stat('input/dir1/hardlink').st_nlink == 2
-            assert os.stat('input/dir1/subdir/hardlink').st_nlink == 2
-            assert os.stat('input/dir1/aaaa').st_nlink == 2
-            assert os.stat('input/dir1/source2').st_nlink == 2
-        with changedir('output'):
-            self.cmd(f'--repo={self.repository_location}', 'extract', 'test2')
-            assert os.stat('input/dir1/hardlink').st_nlink == 4
+        with changedir("output"):
+            self.cmd(f"--repo={self.repository_location}", "extract", "test")
+            assert os.stat("input/dir1/hardlink").st_nlink == 2
+            assert os.stat("input/dir1/subdir/hardlink").st_nlink == 2
+            assert os.stat("input/dir1/aaaa").st_nlink == 2
+            assert os.stat("input/dir1/source2").st_nlink == 2
+        with changedir("output"):
+            self.cmd(f"--repo={self.repository_location}", "extract", "test2")
+            assert os.stat("input/dir1/hardlink").st_nlink == 4
 
     def test_recreate_rechunkify(self):
-        with open(os.path.join(self.input_path, 'large_file'), 'wb') as fd:
-            fd.write(b'a' * 280)
-            fd.write(b'b' * 280)
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
-        self.cmd(f'--repo={self.repository_location}', 'create', 'test1', 'input', '--chunker-params', '7,9,8,128')
-        self.cmd(f'--repo={self.repository_location}', 'create', 'test2', 'input', '--files-cache=disabled')
-        list = self.cmd(f'--repo={self.repository_location}', 'list', 'test1', 'input/large_file',
-                        '--format', '{num_chunks} {unique_chunks}')
-        num_chunks, unique_chunks = map(int, list.split(' '))
+        with open(os.path.join(self.input_path, "large_file"), "wb") as fd:
+            fd.write(b"a" * 280)
+            fd.write(b"b" * 280)
+        self.cmd(f"--repo={self.repository_location}", "rcreate", RK_ENCRYPTION)
+        self.cmd(f"--repo={self.repository_location}", "create", "test1", "input", "--chunker-params", "7,9,8,128")
+        self.cmd(f"--repo={self.repository_location}", "create", "test2", "input", "--files-cache=disabled")
+        list = self.cmd(
+            f"--repo={self.repository_location}",
+            "list",
+            "test1",
+            "input/large_file",
+            "--format",
+            "{num_chunks} {unique_chunks}",
+        )
+        num_chunks, unique_chunks = map(int, list.split(" "))
         # test1 and test2 do not deduplicate
         assert num_chunks == unique_chunks
-        self.cmd(f'--repo={self.repository_location}', 'recreate', '--chunker-params', 'default')
+        self.cmd(f"--repo={self.repository_location}", "recreate", "--chunker-params", "default")
         self.check_cache()
         # test1 and test2 do deduplicate after recreate
-        assert int(self.cmd(f'--repo={self.repository_location}', 'list', 'test1', 'input/large_file', '--format={size}'))
-        assert not int(self.cmd(f'--repo={self.repository_location}', 'list', 'test1', 'input/large_file',
-                                '--format', '{unique_chunks}'))
+        assert int(
+            self.cmd(f"--repo={self.repository_location}", "list", "test1", "input/large_file", "--format={size}")
+        )
+        assert not int(
+            self.cmd(
+                f"--repo={self.repository_location}", "list", "test1", "input/large_file", "--format", "{unique_chunks}"
+            )
+        )
 
     def test_recreate_recompress(self):
-        self.create_regular_file('compressible', size=10000)
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
-        self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input', '-C', 'none')
-        file_list = self.cmd(f'--repo={self.repository_location}', 'list', 'test', 'input/compressible',
-                             '--format', '{size} {sha256}')
-        size, sha256_before = file_list.split(' ')
-        self.cmd(f'--repo={self.repository_location}', 'recreate', '-C', 'lz4', '--recompress')
+        self.create_regular_file("compressible", size=10000)
+        self.cmd(f"--repo={self.repository_location}", "rcreate", RK_ENCRYPTION)
+        self.cmd(f"--repo={self.repository_location}", "create", "test", "input", "-C", "none")
+        file_list = self.cmd(
+            f"--repo={self.repository_location}", "list", "test", "input/compressible", "--format", "{size} {sha256}"
+        )
+        size, sha256_before = file_list.split(" ")
+        self.cmd(f"--repo={self.repository_location}", "recreate", "-C", "lz4", "--recompress")
         self.check_cache()
-        file_list = self.cmd(f'--repo={self.repository_location}', 'list', 'test', 'input/compressible',
-                             '--format', '{size} {sha256}')
-        size, sha256_after = file_list.split(' ')
+        file_list = self.cmd(
+            f"--repo={self.repository_location}", "list", "test", "input/compressible", "--format", "{size} {sha256}"
+        )
+        size, sha256_after = file_list.split(" ")
         assert sha256_before == sha256_after
 
     def test_recreate_timestamp(self):
         local_timezone = datetime.now(timezone(timedelta(0))).astimezone().tzinfo
         self.create_test_files()
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
-        self.cmd(f'--repo={self.repository_location}', 'create', 'test0', 'input')
-        self.cmd(f'--repo={self.repository_location}', 'recreate', 'test0', '--timestamp', "1970-01-02T00:00:00",
-                 '--comment', 'test')
-        info = self.cmd(f'--repo={self.repository_location}', 'info', '-a', 'test0').splitlines()
+        self.cmd(f"--repo={self.repository_location}", "rcreate", RK_ENCRYPTION)
+        self.cmd(f"--repo={self.repository_location}", "create", "test0", "input")
+        self.cmd(
+            f"--repo={self.repository_location}",
+            "recreate",
+            "test0",
+            "--timestamp",
+            "1970-01-02T00:00:00",
+            "--comment",
+            "test",
+        )
+        info = self.cmd(f"--repo={self.repository_location}", "info", "-a", "test0").splitlines()
         dtime = datetime(1970, 1, 2) + local_timezone.utcoffset(None)
         s_time = dtime.strftime("%Y-%m-%d")
-        assert any([re.search(r'Time \(start\).+ %s' % s_time, item) for item in info])
-        assert any([re.search(r'Time \(end\).+ %s' % s_time, item) for item in info])
+        assert any([re.search(r"Time \(start\).+ %s" % s_time, item) for item in info])
+        assert any([re.search(r"Time \(end\).+ %s" % s_time, item) for item in info])
 
     def test_recreate_dry_run(self):
-        self.create_regular_file('compressible', size=10000)
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
-        self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
-        archives_before = self.cmd(f'--repo={self.repository_location}', 'list', 'test')
-        self.cmd(f'--repo={self.repository_location}', 'recreate', '-n', '-e', 'input/compressible')
+        self.create_regular_file("compressible", size=10000)
+        self.cmd(f"--repo={self.repository_location}", "rcreate", RK_ENCRYPTION)
+        self.cmd(f"--repo={self.repository_location}", "create", "test", "input")
+        archives_before = self.cmd(f"--repo={self.repository_location}", "list", "test")
+        self.cmd(f"--repo={self.repository_location}", "recreate", "-n", "-e", "input/compressible")
         self.check_cache()
-        archives_after = self.cmd(f'--repo={self.repository_location}', 'list', 'test')
+        archives_after = self.cmd(f"--repo={self.repository_location}", "list", "test")
         assert archives_after == archives_before
 
     def test_recreate_skips_nothing_to_do(self):
-        self.create_regular_file('file1', size=1024 * 80)
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
-        self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
-        info_before = self.cmd(f'--repo={self.repository_location}', 'info', '-a', 'test')
-        self.cmd(f'--repo={self.repository_location}', 'recreate', '--chunker-params', 'default')
+        self.create_regular_file("file1", size=1024 * 80)
+        self.cmd(f"--repo={self.repository_location}", "rcreate", RK_ENCRYPTION)
+        self.cmd(f"--repo={self.repository_location}", "create", "test", "input")
+        info_before = self.cmd(f"--repo={self.repository_location}", "info", "-a", "test")
+        self.cmd(f"--repo={self.repository_location}", "recreate", "--chunker-params", "default")
         self.check_cache()
-        info_after = self.cmd(f'--repo={self.repository_location}', 'info', '-a', 'test')
+        info_after = self.cmd(f"--repo={self.repository_location}", "info", "-a", "test")
         assert info_before == info_after  # includes archive ID
 
     def test_with_lock(self):
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
-        lock_path = os.path.join(self.repository_path, 'lock.exclusive')
-        cmd = 'python3', '-c', 'import os, sys; sys.exit(42 if os.path.exists("%s") else 23)' % lock_path
-        self.cmd(f'--repo={self.repository_location}', 'with-lock', *cmd, fork=True, exit_code=42)
+        self.cmd(f"--repo={self.repository_location}", "rcreate", RK_ENCRYPTION)
+        lock_path = os.path.join(self.repository_path, "lock.exclusive")
+        cmd = "python3", "-c", 'import os, sys; sys.exit(42 if os.path.exists("%s") else 23)' % lock_path
+        self.cmd(f"--repo={self.repository_location}", "with-lock", *cmd, fork=True, exit_code=42)
 
     def test_recreate_list_output(self):
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
-        self.create_regular_file('file1', size=0)
-        self.create_regular_file('file2', size=0)
-        self.create_regular_file('file3', size=0)
-        self.create_regular_file('file4', size=0)
-        self.create_regular_file('file5', size=0)
+        self.cmd(f"--repo={self.repository_location}", "rcreate", RK_ENCRYPTION)
+        self.create_regular_file("file1", size=0)
+        self.create_regular_file("file2", size=0)
+        self.create_regular_file("file3", size=0)
+        self.create_regular_file("file4", size=0)
+        self.create_regular_file("file5", size=0)
 
-        self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
+        self.cmd(f"--repo={self.repository_location}", "create", "test", "input")
 
-        output = self.cmd(f'--repo={self.repository_location}', 'recreate', '-a', 'test', '--list', '--info', '-e', 'input/file2')
+        output = self.cmd(
+            f"--repo={self.repository_location}", "recreate", "-a", "test", "--list", "--info", "-e", "input/file2"
+        )
         self.check_cache()
         self.assert_in("input/file1", output)
         self.assert_in("x input/file2", output)
 
-        output = self.cmd(f'--repo={self.repository_location}', 'recreate', '-a', 'test', '--list', '-e', 'input/file3')
+        output = self.cmd(f"--repo={self.repository_location}", "recreate", "-a", "test", "--list", "-e", "input/file3")
         self.check_cache()
         self.assert_in("input/file1", output)
         self.assert_in("x input/file3", output)
 
-        output = self.cmd(f'--repo={self.repository_location}', 'recreate', '-a', 'test', '-e', 'input/file4')
+        output = self.cmd(f"--repo={self.repository_location}", "recreate", "-a", "test", "-e", "input/file4")
         self.check_cache()
         self.assert_not_in("input/file1", output)
         self.assert_not_in("x input/file4", output)
 
-        output = self.cmd(f'--repo={self.repository_location}', 'recreate', '-a', 'test', '--info', '-e', 'input/file5')
+        output = self.cmd(f"--repo={self.repository_location}", "recreate", "-a", "test", "--info", "-e", "input/file5")
         self.check_cache()
         self.assert_not_in("input/file1", output)
         self.assert_not_in("x input/file5", output)
 
     def test_bad_filters(self):
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
-        self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
-        self.cmd(f'--repo={self.repository_location}', 'delete', '--first', '1', '--last', '1', fork=True, exit_code=2)
+        self.cmd(f"--repo={self.repository_location}", "rcreate", RK_ENCRYPTION)
+        self.cmd(f"--repo={self.repository_location}", "create", "test", "input")
+        self.cmd(f"--repo={self.repository_location}", "delete", "--first", "1", "--last", "1", fork=True, exit_code=2)
 
     def test_key_export_keyfile(self):
-        export_file = self.output_path + '/exported'
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', KF_ENCRYPTION)
+        export_file = self.output_path + "/exported"
+        self.cmd(f"--repo={self.repository_location}", "rcreate", KF_ENCRYPTION)
         repo_id = self._extract_repository_id(self.repository_path)
-        self.cmd(f'--repo={self.repository_location}', 'key', 'export', export_file)
+        self.cmd(f"--repo={self.repository_location}", "key", "export", export_file)
 
         with open(export_file) as fd:
             export_contents = fd.read()
 
-        assert export_contents.startswith('BORG_KEY ' + bin_to_hex(repo_id) + '\n')
+        assert export_contents.startswith("BORG_KEY " + bin_to_hex(repo_id) + "\n")
 
-        key_file = self.keys_path + '/' + os.listdir(self.keys_path)[0]
+        key_file = self.keys_path + "/" + os.listdir(self.keys_path)[0]
 
         with open(key_file) as fd:
             key_contents = fd.read()
@@ -3049,7 +3300,7 @@ class ArchiverTestCase(ArchiverTestCaseBase):
 
         os.unlink(key_file)
 
-        self.cmd(f'--repo={self.repository_location}', 'key', 'import', export_file)
+        self.cmd(f"--repo={self.repository_location}", "key", "import", export_file)
 
         with open(key_file) as fd:
             key_contents2 = fd.read()
@@ -3057,19 +3308,19 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         assert key_contents2 == key_contents
 
     def test_key_import_keyfile_with_borg_key_file(self):
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', KF_ENCRYPTION)
+        self.cmd(f"--repo={self.repository_location}", "rcreate", KF_ENCRYPTION)
 
-        exported_key_file = os.path.join(self.output_path, 'exported')
-        self.cmd(f'--repo={self.repository_location}', 'key', 'export', exported_key_file)
+        exported_key_file = os.path.join(self.output_path, "exported")
+        self.cmd(f"--repo={self.repository_location}", "key", "export", exported_key_file)
 
         key_file = os.path.join(self.keys_path, os.listdir(self.keys_path)[0])
         with open(key_file) as fd:
             key_contents = fd.read()
         os.unlink(key_file)
 
-        imported_key_file = os.path.join(self.output_path, 'imported')
+        imported_key_file = os.path.join(self.output_path, "imported")
         with environment_variable(BORG_KEY_FILE=imported_key_file):
-            self.cmd(f'--repo={self.repository_location}', 'key', 'import', exported_key_file)
+            self.cmd(f"--repo={self.repository_location}", "key", "import", exported_key_file)
         assert not os.path.isfile(key_file), '"borg key import" should respect BORG_KEY_FILE'
 
         with open(imported_key_file) as fd:
@@ -3077,15 +3328,15 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         assert imported_key_contents == key_contents
 
     def test_key_export_repokey(self):
-        export_file = self.output_path + '/exported'
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
+        export_file = self.output_path + "/exported"
+        self.cmd(f"--repo={self.repository_location}", "rcreate", RK_ENCRYPTION)
         repo_id = self._extract_repository_id(self.repository_path)
-        self.cmd(f'--repo={self.repository_location}', 'key', 'export', export_file)
+        self.cmd(f"--repo={self.repository_location}", "key", "export", export_file)
 
         with open(export_file) as fd:
             export_contents = fd.read()
 
-        assert export_contents.startswith('BORG_KEY ' + bin_to_hex(repo_id) + '\n')
+        assert export_contents.startswith("BORG_KEY " + bin_to_hex(repo_id) + "\n")
 
         with Repository(self.repository_path) as repository:
             repo_key = AESOCBRepoKey(repository)
@@ -3097,9 +3348,9 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         assert repo_key.enc_key == backup_key.enc_key
 
         with Repository(self.repository_path) as repository:
-            repository.save_key(b'')
+            repository.save_key(b"")
 
-        self.cmd(f'--repo={self.repository_location}', 'key', 'import', export_file)
+        self.cmd(f"--repo={self.repository_location}", "key", "import", export_file)
 
         with Repository(self.repository_path) as repository:
             repo_key2 = AESOCBRepoKey(repository)
@@ -3108,102 +3359,104 @@ class ArchiverTestCase(ArchiverTestCaseBase):
         assert repo_key2.enc_key == repo_key2.enc_key
 
     def test_key_export_qr(self):
-        export_file = self.output_path + '/exported.html'
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
+        export_file = self.output_path + "/exported.html"
+        self.cmd(f"--repo={self.repository_location}", "rcreate", RK_ENCRYPTION)
         repo_id = self._extract_repository_id(self.repository_path)
-        self.cmd(f'--repo={self.repository_location}', 'key', 'export', '--qr-html', export_file)
+        self.cmd(f"--repo={self.repository_location}", "key", "export", "--qr-html", export_file)
 
-        with open(export_file, encoding='utf-8') as fd:
+        with open(export_file, encoding="utf-8") as fd:
             export_contents = fd.read()
 
         assert bin_to_hex(repo_id) in export_contents
-        assert export_contents.startswith('<!doctype html>')
-        assert export_contents.endswith('</html>\n')
+        assert export_contents.startswith("<!doctype html>")
+        assert export_contents.endswith("</html>\n")
 
     def test_key_export_directory(self):
-        export_directory = self.output_path + '/exported'
+        export_directory = self.output_path + "/exported"
         os.mkdir(export_directory)
 
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
+        self.cmd(f"--repo={self.repository_location}", "rcreate", RK_ENCRYPTION)
 
-        self.cmd(f'--repo={self.repository_location}', 'key', 'export', export_directory, exit_code=EXIT_ERROR)
+        self.cmd(f"--repo={self.repository_location}", "key", "export", export_directory, exit_code=EXIT_ERROR)
 
     def test_key_import_errors(self):
-        export_file = self.output_path + '/exported'
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', KF_ENCRYPTION)
+        export_file = self.output_path + "/exported"
+        self.cmd(f"--repo={self.repository_location}", "rcreate", KF_ENCRYPTION)
 
-        self.cmd(f'--repo={self.repository_location}', 'key', 'import', export_file, exit_code=EXIT_ERROR)
+        self.cmd(f"--repo={self.repository_location}", "key", "import", export_file, exit_code=EXIT_ERROR)
 
-        with open(export_file, 'w') as fd:
-            fd.write('something not a key\n')
+        with open(export_file, "w") as fd:
+            fd.write("something not a key\n")
 
         if self.FORK_DEFAULT:
-            self.cmd(f'--repo={self.repository_location}', 'key', 'import', export_file, exit_code=2)
+            self.cmd(f"--repo={self.repository_location}", "key", "import", export_file, exit_code=2)
         else:
             with pytest.raises(NotABorgKeyFile):
-                self.cmd(f'--repo={self.repository_location}', 'key', 'import', export_file)
+                self.cmd(f"--repo={self.repository_location}", "key", "import", export_file)
 
-        with open(export_file, 'w') as fd:
-            fd.write('BORG_KEY a0a0a0\n')
+        with open(export_file, "w") as fd:
+            fd.write("BORG_KEY a0a0a0\n")
 
         if self.FORK_DEFAULT:
-            self.cmd(f'--repo={self.repository_location}', 'key', 'import', export_file, exit_code=2)
+            self.cmd(f"--repo={self.repository_location}", "key", "import", export_file, exit_code=2)
         else:
             with pytest.raises(RepoIdMismatch):
-                self.cmd(f'--repo={self.repository_location}', 'key', 'import', export_file)
+                self.cmd(f"--repo={self.repository_location}", "key", "import", export_file)
 
     def test_key_export_paperkey(self):
-        repo_id = 'e294423506da4e1ea76e8dcdf1a3919624ae3ae496fddf905610c351d3f09239'
+        repo_id = "e294423506da4e1ea76e8dcdf1a3919624ae3ae496fddf905610c351d3f09239"
 
-        export_file = self.output_path + '/exported'
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', KF_ENCRYPTION)
+        export_file = self.output_path + "/exported"
+        self.cmd(f"--repo={self.repository_location}", "rcreate", KF_ENCRYPTION)
         self._set_repository_id(self.repository_path, unhexlify(repo_id))
 
-        key_file = self.keys_path + '/' + os.listdir(self.keys_path)[0]
+        key_file = self.keys_path + "/" + os.listdir(self.keys_path)[0]
 
-        with open(key_file, 'w') as fd:
-            fd.write(CHPOKeyfileKey.FILE_ID + ' ' + repo_id + '\n')
-            fd.write(b2a_base64(b'abcdefghijklmnopqrstu').decode())
+        with open(key_file, "w") as fd:
+            fd.write(CHPOKeyfileKey.FILE_ID + " " + repo_id + "\n")
+            fd.write(b2a_base64(b"abcdefghijklmnopqrstu").decode())
 
-        self.cmd(f'--repo={self.repository_location}', 'key', 'export', '--paper', export_file)
+        self.cmd(f"--repo={self.repository_location}", "key", "export", "--paper", export_file)
 
         with open(export_file) as fd:
             export_contents = fd.read()
 
-        assert export_contents == """To restore key use borg key import --paper /path/to/repo
+        assert (
+            export_contents
+            == """To restore key use borg key import --paper /path/to/repo
 
 BORG PAPER KEY v1
 id: 2 / e29442 3506da 4e1ea7 / 25f62a 5a3d41 - 02
  1: 616263 646566 676869 6a6b6c 6d6e6f 707172 - 6d
  2: 737475 - 88
 """
+        )
 
     def test_key_import_paperkey(self):
-        repo_id = 'e294423506da4e1ea76e8dcdf1a3919624ae3ae496fddf905610c351d3f09239'
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', KF_ENCRYPTION)
+        repo_id = "e294423506da4e1ea76e8dcdf1a3919624ae3ae496fddf905610c351d3f09239"
+        self.cmd(f"--repo={self.repository_location}", "rcreate", KF_ENCRYPTION)
         self._set_repository_id(self.repository_path, unhexlify(repo_id))
 
-        key_file = self.keys_path + '/' + os.listdir(self.keys_path)[0]
-        with open(key_file, 'w') as fd:
-            fd.write(AESOCBKeyfileKey.FILE_ID + ' ' + repo_id + '\n')
-            fd.write(b2a_base64(b'abcdefghijklmnopqrstu').decode())
+        key_file = self.keys_path + "/" + os.listdir(self.keys_path)[0]
+        with open(key_file, "w") as fd:
+            fd.write(AESOCBKeyfileKey.FILE_ID + " " + repo_id + "\n")
+            fd.write(b2a_base64(b"abcdefghijklmnopqrstu").decode())
 
         typed_input = (
-            b'2 / e29442 3506da 4e1ea7 / 25f62a 5a3d41  02\n'   # Forgot to type "-"
-            b'2 / e29442 3506da 4e1ea7  25f62a 5a3d41 - 02\n'   # Forgot to type second "/"
-            b'2 / e29442 3506da 4e1ea7 / 25f62a 5a3d42 - 02\n'  # Typo (..42 not ..41)
-            b'2 / e29442 3506da 4e1ea7 / 25f62a 5a3d41 - 02\n'  # Correct! Congratulations
-            b'616263 646566 676869 6a6b6c 6d6e6f 707172 - 6d\n'
-            b'\n\n'  # Abort [yN] => N
-            b'737475 88\n'  # missing "-"
-            b'73747i - 88\n'  # typo
-            b'73747 - 88\n'  # missing nibble
-            b'73 74 75  -  89\n'  # line checksum mismatch
-            b'00a1 - 88\n'  # line hash collision - overall hash mismatch, have to start over
-
-            b'2 / e29442 3506da 4e1ea7 / 25f62a 5a3d41 - 02\n'
-            b'616263 646566 676869 6a6b6c 6d6e6f 707172 - 6d\n'
-            b'73 74 75  -  88\n'
+            b"2 / e29442 3506da 4e1ea7 / 25f62a 5a3d41  02\n"  # Forgot to type "-"
+            b"2 / e29442 3506da 4e1ea7  25f62a 5a3d41 - 02\n"  # Forgot to type second "/"
+            b"2 / e29442 3506da 4e1ea7 / 25f62a 5a3d42 - 02\n"  # Typo (..42 not ..41)
+            b"2 / e29442 3506da 4e1ea7 / 25f62a 5a3d41 - 02\n"  # Correct! Congratulations
+            b"616263 646566 676869 6a6b6c 6d6e6f 707172 - 6d\n"
+            b"\n\n"  # Abort [yN] => N
+            b"737475 88\n"  # missing "-"
+            b"73747i - 88\n"  # typo
+            b"73747 - 88\n"  # missing nibble
+            b"73 74 75  -  89\n"  # line checksum mismatch
+            b"00a1 - 88\n"  # line hash collision - overall hash mismatch, have to start over
+            b"2 / e29442 3506da 4e1ea7 / 25f62a 5a3d41 - 02\n"
+            b"616263 646566 676869 6a6b6c 6d6e6f 707172 - 6d\n"
+            b"73 74 75  -  88\n"
         )
 
         # In case that this has to change, here is a quick way to find a colliding line hash:
@@ -3215,648 +3468,718 @@ id: 2 / e29442 3506da 4e1ea7 / 25f62a 5a3d41 - 02
         #         print(i.to_bytes(2, 'big'))
         #         break
 
-        self.cmd(f'--repo={self.repository_location}', 'key', 'import', '--paper', input=typed_input)
+        self.cmd(f"--repo={self.repository_location}", "key", "import", "--paper", input=typed_input)
 
         # Test abort paths
-        typed_input = b'\ny\n'
-        self.cmd(f'--repo={self.repository_location}', 'key', 'import', '--paper', input=typed_input)
-        typed_input = b'2 / e29442 3506da 4e1ea7 / 25f62a 5a3d41 - 02\n\ny\n'
-        self.cmd(f'--repo={self.repository_location}', 'key', 'import', '--paper', input=typed_input)
+        typed_input = b"\ny\n"
+        self.cmd(f"--repo={self.repository_location}", "key", "import", "--paper", input=typed_input)
+        typed_input = b"2 / e29442 3506da 4e1ea7 / 25f62a 5a3d41 - 02\n\ny\n"
+        self.cmd(f"--repo={self.repository_location}", "key", "import", "--paper", input=typed_input)
 
     def test_debug_dump_manifest(self):
-        self.create_regular_file('file1', size=1024 * 80)
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
-        self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
-        dump_file = self.output_path + '/dump'
-        output = self.cmd(f'--repo={self.repository_location}', 'debug', 'dump-manifest', dump_file)
+        self.create_regular_file("file1", size=1024 * 80)
+        self.cmd(f"--repo={self.repository_location}", "rcreate", RK_ENCRYPTION)
+        self.cmd(f"--repo={self.repository_location}", "create", "test", "input")
+        dump_file = self.output_path + "/dump"
+        output = self.cmd(f"--repo={self.repository_location}", "debug", "dump-manifest", dump_file)
         assert output == ""
         with open(dump_file) as f:
             result = json.load(f)
-        assert 'archives' in result
-        assert 'config' in result
-        assert 'item_keys' in result
-        assert 'timestamp' in result
-        assert 'version' in result
+        assert "archives" in result
+        assert "config" in result
+        assert "item_keys" in result
+        assert "timestamp" in result
+        assert "version" in result
 
     def test_debug_dump_archive(self):
-        self.create_regular_file('file1', size=1024 * 80)
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
-        self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
-        dump_file = self.output_path + '/dump'
-        output = self.cmd(f'--repo={self.repository_location}', 'debug', 'dump-archive', 'test', dump_file)
+        self.create_regular_file("file1", size=1024 * 80)
+        self.cmd(f"--repo={self.repository_location}", "rcreate", RK_ENCRYPTION)
+        self.cmd(f"--repo={self.repository_location}", "create", "test", "input")
+        dump_file = self.output_path + "/dump"
+        output = self.cmd(f"--repo={self.repository_location}", "debug", "dump-archive", "test", dump_file)
         assert output == ""
         with open(dump_file) as f:
             result = json.load(f)
-        assert '_name' in result
-        assert '_manifest_entry' in result
-        assert '_meta' in result
-        assert '_items' in result
+        assert "_name" in result
+        assert "_manifest_entry" in result
+        assert "_meta" in result
+        assert "_items" in result
 
     def test_debug_refcount_obj(self):
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
-        output = self.cmd(f'--repo={self.repository_location}', 'debug', 'refcount-obj', '0' * 64).strip()
-        assert output == 'object 0000000000000000000000000000000000000000000000000000000000000000 not found [info from chunks cache].'
+        self.cmd(f"--repo={self.repository_location}", "rcreate", RK_ENCRYPTION)
+        output = self.cmd(f"--repo={self.repository_location}", "debug", "refcount-obj", "0" * 64).strip()
+        assert (
+            output
+            == "object 0000000000000000000000000000000000000000000000000000000000000000 not found [info from chunks cache]."
+        )
 
-        create_json = json.loads(self.cmd(f'--repo={self.repository_location}', 'create', '--json', 'test', 'input'))
-        archive_id = create_json['archive']['id']
-        output = self.cmd(f'--repo={self.repository_location}', 'debug', 'refcount-obj', archive_id).strip()
-        assert output == 'object ' + archive_id + ' has 1 referrers [info from chunks cache].'
+        create_json = json.loads(self.cmd(f"--repo={self.repository_location}", "create", "--json", "test", "input"))
+        archive_id = create_json["archive"]["id"]
+        output = self.cmd(f"--repo={self.repository_location}", "debug", "refcount-obj", archive_id).strip()
+        assert output == "object " + archive_id + " has 1 referrers [info from chunks cache]."
 
         # Invalid IDs do not abort or return an error
-        output = self.cmd(f'--repo={self.repository_location}', 'debug', 'refcount-obj', '124', 'xyza').strip()
-        assert output == 'object id 124 is invalid.\nobject id xyza is invalid.'
+        output = self.cmd(f"--repo={self.repository_location}", "debug", "refcount-obj", "124", "xyza").strip()
+        assert output == "object id 124 is invalid.\nobject id xyza is invalid."
 
     def test_debug_info(self):
-        output = self.cmd('debug', 'info')
-        assert 'CRC implementation' in output
-        assert 'Python' in output
+        output = self.cmd("debug", "info")
+        assert "CRC implementation" in output
+        assert "Python" in output
 
     def test_benchmark_crud(self):
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
-        with environment_variable(_BORG_BENCHMARK_CRUD_TEST='YES'):
-            self.cmd(f'--repo={self.repository_location}', 'benchmark', 'crud', self.input_path)
+        self.cmd(f"--repo={self.repository_location}", "rcreate", RK_ENCRYPTION)
+        with environment_variable(_BORG_BENCHMARK_CRUD_TEST="YES"):
+            self.cmd(f"--repo={self.repository_location}", "benchmark", "crud", self.input_path)
 
     def test_config(self):
         self.create_test_files()
-        os.unlink('input/flagfile')
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
-        output = self.cmd(f'--repo={self.repository_location}', 'config', '--list')
-        self.assert_in('[repository]', output)
-        self.assert_in('version', output)
-        self.assert_in('segments_per_dir', output)
-        self.assert_in('storage_quota', output)
-        self.assert_in('append_only', output)
-        self.assert_in('additional_free_space', output)
-        self.assert_in('id', output)
-        self.assert_not_in('last_segment_checked', output)
+        os.unlink("input/flagfile")
+        self.cmd(f"--repo={self.repository_location}", "rcreate", RK_ENCRYPTION)
+        output = self.cmd(f"--repo={self.repository_location}", "config", "--list")
+        self.assert_in("[repository]", output)
+        self.assert_in("version", output)
+        self.assert_in("segments_per_dir", output)
+        self.assert_in("storage_quota", output)
+        self.assert_in("append_only", output)
+        self.assert_in("additional_free_space", output)
+        self.assert_in("id", output)
+        self.assert_not_in("last_segment_checked", output)
 
-        output = self.cmd(f'--repo={self.repository_location}', 'config', 'last_segment_checked', exit_code=1)
-        self.assert_in('No option ', output)
-        self.cmd(f'--repo={self.repository_location}', 'config', 'last_segment_checked', '123')
-        output = self.cmd(f'--repo={self.repository_location}', 'config', 'last_segment_checked')
-        assert output == '123' + '\n'
-        output = self.cmd(f'--repo={self.repository_location}', 'config', '--list')
-        self.assert_in('last_segment_checked', output)
-        self.cmd(f'--repo={self.repository_location}', 'config', '--delete', 'last_segment_checked')
+        output = self.cmd(f"--repo={self.repository_location}", "config", "last_segment_checked", exit_code=1)
+        self.assert_in("No option ", output)
+        self.cmd(f"--repo={self.repository_location}", "config", "last_segment_checked", "123")
+        output = self.cmd(f"--repo={self.repository_location}", "config", "last_segment_checked")
+        assert output == "123" + "\n"
+        output = self.cmd(f"--repo={self.repository_location}", "config", "--list")
+        self.assert_in("last_segment_checked", output)
+        self.cmd(f"--repo={self.repository_location}", "config", "--delete", "last_segment_checked")
 
-        for cfg_key, cfg_value in [
-            ('additional_free_space', '2G'),
-            ('repository.append_only', '1'),
-        ]:
-            output = self.cmd(f'--repo={self.repository_location}', 'config', cfg_key)
-            assert output == '0' + '\n'
-            self.cmd(f'--repo={self.repository_location}', 'config', cfg_key, cfg_value)
-            output = self.cmd(f'--repo={self.repository_location}', 'config', cfg_key)
-            assert output == cfg_value + '\n'
-            self.cmd(f'--repo={self.repository_location}', 'config', '--delete', cfg_key)
-            self.cmd(f'--repo={self.repository_location}', 'config', cfg_key, exit_code=1)
+        for cfg_key, cfg_value in [("additional_free_space", "2G"), ("repository.append_only", "1")]:
+            output = self.cmd(f"--repo={self.repository_location}", "config", cfg_key)
+            assert output == "0" + "\n"
+            self.cmd(f"--repo={self.repository_location}", "config", cfg_key, cfg_value)
+            output = self.cmd(f"--repo={self.repository_location}", "config", cfg_key)
+            assert output == cfg_value + "\n"
+            self.cmd(f"--repo={self.repository_location}", "config", "--delete", cfg_key)
+            self.cmd(f"--repo={self.repository_location}", "config", cfg_key, exit_code=1)
 
-        self.cmd(f'--repo={self.repository_location}', 'config', '--list', '--delete', exit_code=2)
-        self.cmd(f'--repo={self.repository_location}', 'config', exit_code=2)
-        self.cmd(f'--repo={self.repository_location}', 'config', 'invalid-option', exit_code=1)
+        self.cmd(f"--repo={self.repository_location}", "config", "--list", "--delete", exit_code=2)
+        self.cmd(f"--repo={self.repository_location}", "config", exit_code=2)
+        self.cmd(f"--repo={self.repository_location}", "config", "invalid-option", exit_code=1)
 
-    requires_gnutar = pytest.mark.skipif(not have_gnutar(), reason='GNU tar must be installed for this test.')
-    requires_gzip = pytest.mark.skipif(not shutil.which('gzip'), reason='gzip must be installed for this test.')
+    requires_gnutar = pytest.mark.skipif(not have_gnutar(), reason="GNU tar must be installed for this test.")
+    requires_gzip = pytest.mark.skipif(not shutil.which("gzip"), reason="gzip must be installed for this test.")
 
     @requires_gnutar
     def test_export_tar(self):
         self.create_test_files()
-        os.unlink('input/flagfile')
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
-        self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
-        self.cmd(f'--repo={self.repository_location}', 'export-tar', 'test', 'simple.tar', '--progress', '--tar-format=GNU')
-        with changedir('output'):
+        os.unlink("input/flagfile")
+        self.cmd(f"--repo={self.repository_location}", "rcreate", RK_ENCRYPTION)
+        self.cmd(f"--repo={self.repository_location}", "create", "test", "input")
+        self.cmd(
+            f"--repo={self.repository_location}", "export-tar", "test", "simple.tar", "--progress", "--tar-format=GNU"
+        )
+        with changedir("output"):
             # This probably assumes GNU tar. Note -p switch to extract permissions regardless of umask.
-            subprocess.check_call(['tar', 'xpf', '../simple.tar', '--warning=no-timestamp'])
-        self.assert_dirs_equal('input', 'output/input', ignore_flags=True, ignore_xattrs=True, ignore_ns=True)
+            subprocess.check_call(["tar", "xpf", "../simple.tar", "--warning=no-timestamp"])
+        self.assert_dirs_equal("input", "output/input", ignore_flags=True, ignore_xattrs=True, ignore_ns=True)
 
     @requires_gnutar
     @requires_gzip
     def test_export_tar_gz(self):
-        if not shutil.which('gzip'):
-            pytest.skip('gzip is not installed')
+        if not shutil.which("gzip"):
+            pytest.skip("gzip is not installed")
         self.create_test_files()
-        os.unlink('input/flagfile')
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
-        self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
-        list = self.cmd(f'--repo={self.repository_location}', 'export-tar', 'test', 'simple.tar.gz',
-                        '--list', '--tar-format=GNU')
-        assert 'input/file1\n' in list
-        assert 'input/dir2\n' in list
-        with changedir('output'):
-            subprocess.check_call(['tar', 'xpf', '../simple.tar.gz', '--warning=no-timestamp'])
-        self.assert_dirs_equal('input', 'output/input', ignore_flags=True, ignore_xattrs=True, ignore_ns=True)
+        os.unlink("input/flagfile")
+        self.cmd(f"--repo={self.repository_location}", "rcreate", RK_ENCRYPTION)
+        self.cmd(f"--repo={self.repository_location}", "create", "test", "input")
+        list = self.cmd(
+            f"--repo={self.repository_location}", "export-tar", "test", "simple.tar.gz", "--list", "--tar-format=GNU"
+        )
+        assert "input/file1\n" in list
+        assert "input/dir2\n" in list
+        with changedir("output"):
+            subprocess.check_call(["tar", "xpf", "../simple.tar.gz", "--warning=no-timestamp"])
+        self.assert_dirs_equal("input", "output/input", ignore_flags=True, ignore_xattrs=True, ignore_ns=True)
 
     @requires_gnutar
     def test_export_tar_strip_components(self):
-        if not shutil.which('gzip'):
-            pytest.skip('gzip is not installed')
+        if not shutil.which("gzip"):
+            pytest.skip("gzip is not installed")
         self.create_test_files()
-        os.unlink('input/flagfile')
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
-        self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
-        list = self.cmd(f'--repo={self.repository_location}', 'export-tar', 'test', 'simple.tar',
-                        '--strip-components=1', '--list', '--tar-format=GNU')
+        os.unlink("input/flagfile")
+        self.cmd(f"--repo={self.repository_location}", "rcreate", RK_ENCRYPTION)
+        self.cmd(f"--repo={self.repository_location}", "create", "test", "input")
+        list = self.cmd(
+            f"--repo={self.repository_location}",
+            "export-tar",
+            "test",
+            "simple.tar",
+            "--strip-components=1",
+            "--list",
+            "--tar-format=GNU",
+        )
         # --list's path are those before processing with --strip-components
-        assert 'input/file1\n' in list
-        assert 'input/dir2\n' in list
-        with changedir('output'):
-            subprocess.check_call(['tar', 'xpf', '../simple.tar', '--warning=no-timestamp'])
-        self.assert_dirs_equal('input', 'output/', ignore_flags=True, ignore_xattrs=True, ignore_ns=True)
+        assert "input/file1\n" in list
+        assert "input/dir2\n" in list
+        with changedir("output"):
+            subprocess.check_call(["tar", "xpf", "../simple.tar", "--warning=no-timestamp"])
+        self.assert_dirs_equal("input", "output/", ignore_flags=True, ignore_xattrs=True, ignore_ns=True)
 
     @requires_hardlinks
     @requires_gnutar
     def test_export_tar_strip_components_links(self):
         self._extract_hardlinks_setup()
-        self.cmd(f'--repo={self.repository_location}', 'export-tar', 'test', 'output.tar',
-                 '--strip-components=2', '--tar-format=GNU')
-        with changedir('output'):
-            subprocess.check_call(['tar', 'xpf', '../output.tar', '--warning=no-timestamp'])
-            assert os.stat('hardlink').st_nlink == 2
-            assert os.stat('subdir/hardlink').st_nlink == 2
-            assert os.stat('aaaa').st_nlink == 2
-            assert os.stat('source2').st_nlink == 2
+        self.cmd(
+            f"--repo={self.repository_location}",
+            "export-tar",
+            "test",
+            "output.tar",
+            "--strip-components=2",
+            "--tar-format=GNU",
+        )
+        with changedir("output"):
+            subprocess.check_call(["tar", "xpf", "../output.tar", "--warning=no-timestamp"])
+            assert os.stat("hardlink").st_nlink == 2
+            assert os.stat("subdir/hardlink").st_nlink == 2
+            assert os.stat("aaaa").st_nlink == 2
+            assert os.stat("source2").st_nlink == 2
 
     @requires_hardlinks
     @requires_gnutar
     def test_extract_hardlinks_tar(self):
         self._extract_hardlinks_setup()
-        self.cmd(f'--repo={self.repository_location}', 'export-tar', 'test', 'output.tar', 'input/dir1', '--tar-format=GNU')
-        with changedir('output'):
-            subprocess.check_call(['tar', 'xpf', '../output.tar', '--warning=no-timestamp'])
-            assert os.stat('input/dir1/hardlink').st_nlink == 2
-            assert os.stat('input/dir1/subdir/hardlink').st_nlink == 2
-            assert os.stat('input/dir1/aaaa').st_nlink == 2
-            assert os.stat('input/dir1/source2').st_nlink == 2
+        self.cmd(
+            f"--repo={self.repository_location}", "export-tar", "test", "output.tar", "input/dir1", "--tar-format=GNU"
+        )
+        with changedir("output"):
+            subprocess.check_call(["tar", "xpf", "../output.tar", "--warning=no-timestamp"])
+            assert os.stat("input/dir1/hardlink").st_nlink == 2
+            assert os.stat("input/dir1/subdir/hardlink").st_nlink == 2
+            assert os.stat("input/dir1/aaaa").st_nlink == 2
+            assert os.stat("input/dir1/source2").st_nlink == 2
 
-    def test_import_tar(self, tar_format='PAX'):
+    def test_import_tar(self, tar_format="PAX"):
         self.create_test_files(create_hardlinks=False)  # hardlinks become separate files
-        os.unlink('input/flagfile')
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=none')
-        self.cmd(f'--repo={self.repository_location}', 'create', 'src', 'input')
-        self.cmd(f'--repo={self.repository_location}', 'export-tar', 'src', 'simple.tar', f'--tar-format={tar_format}')
-        self.cmd(f'--repo={self.repository_location}', 'import-tar', 'dst', 'simple.tar')
+        os.unlink("input/flagfile")
+        self.cmd(f"--repo={self.repository_location}", "rcreate", "--encryption=none")
+        self.cmd(f"--repo={self.repository_location}", "create", "src", "input")
+        self.cmd(f"--repo={self.repository_location}", "export-tar", "src", "simple.tar", f"--tar-format={tar_format}")
+        self.cmd(f"--repo={self.repository_location}", "import-tar", "dst", "simple.tar")
         with changedir(self.output_path):
-            self.cmd(f'--repo={self.repository_location}', 'extract', 'dst')
-        self.assert_dirs_equal('input', 'output/input', ignore_ns=True, ignore_xattrs=True)
+            self.cmd(f"--repo={self.repository_location}", "extract", "dst")
+        self.assert_dirs_equal("input", "output/input", ignore_ns=True, ignore_xattrs=True)
 
     @requires_gzip
-    def test_import_tar_gz(self, tar_format='GNU'):
-        if not shutil.which('gzip'):
-            pytest.skip('gzip is not installed')
+    def test_import_tar_gz(self, tar_format="GNU"):
+        if not shutil.which("gzip"):
+            pytest.skip("gzip is not installed")
         self.create_test_files(create_hardlinks=False)  # hardlinks become separate files
-        os.unlink('input/flagfile')
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=none')
-        self.cmd(f'--repo={self.repository_location}', 'create', 'src', 'input')
-        self.cmd(f'--repo={self.repository_location}', 'export-tar', 'src', 'simple.tgz', f'--tar-format={tar_format}')
-        self.cmd(f'--repo={self.repository_location}', 'import-tar', 'dst', 'simple.tgz')
+        os.unlink("input/flagfile")
+        self.cmd(f"--repo={self.repository_location}", "rcreate", "--encryption=none")
+        self.cmd(f"--repo={self.repository_location}", "create", "src", "input")
+        self.cmd(f"--repo={self.repository_location}", "export-tar", "src", "simple.tgz", f"--tar-format={tar_format}")
+        self.cmd(f"--repo={self.repository_location}", "import-tar", "dst", "simple.tgz")
         with changedir(self.output_path):
-            self.cmd(f'--repo={self.repository_location}', 'extract', 'dst')
-        self.assert_dirs_equal('input', 'output/input', ignore_ns=True, ignore_xattrs=True)
+            self.cmd(f"--repo={self.repository_location}", "extract", "dst")
+        self.assert_dirs_equal("input", "output/input", ignore_ns=True, ignore_xattrs=True)
 
     def test_roundtrip_pax_borg(self):
         self.create_test_files()
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', '--encryption=none')
-        self.cmd(f'--repo={self.repository_location}', 'create', 'src', 'input')
-        self.cmd(f'--repo={self.repository_location}', 'export-tar', 'src', 'simple.tar', '--tar-format=BORG')
-        self.cmd(f'--repo={self.repository_location}', 'import-tar', 'dst', 'simple.tar')
+        self.cmd(f"--repo={self.repository_location}", "rcreate", "--encryption=none")
+        self.cmd(f"--repo={self.repository_location}", "create", "src", "input")
+        self.cmd(f"--repo={self.repository_location}", "export-tar", "src", "simple.tar", "--tar-format=BORG")
+        self.cmd(f"--repo={self.repository_location}", "import-tar", "dst", "simple.tar")
         with changedir(self.output_path):
-            self.cmd(f'--repo={self.repository_location}', 'extract', 'dst')
-        self.assert_dirs_equal('input', 'output/input')
+            self.cmd(f"--repo={self.repository_location}", "extract", "dst")
+        self.assert_dirs_equal("input", "output/input")
 
     # derived from test_extract_xattrs_errors()
-    @pytest.mark.skipif(not xattr.XATTR_FAKEROOT, reason='xattr not supported on this system or on this version of'
-                                                         'fakeroot')
+    @pytest.mark.skipif(
+        not xattr.XATTR_FAKEROOT, reason="xattr not supported on this system or on this version of" "fakeroot"
+    )
     def test_do_not_fail_when_percent_is_in_xattr_name(self):
         """https://github.com/borgbackup/borg/issues/6063"""
-        def patched_setxattr_EACCES(*args, **kwargs):
-            raise OSError(errno.EACCES, 'EACCES')
 
-        self.create_regular_file('file')
-        xattr.setxattr(b'input/file', b'user.attribute%p', b'value')
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', '-e' 'none')
-        self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
-        with changedir('output'):
-            with patch.object(xattr, 'setxattr', patched_setxattr_EACCES):
-                self.cmd(f'--repo={self.repository_location}', 'extract', 'test', exit_code=EXIT_WARNING)
+        def patched_setxattr_EACCES(*args, **kwargs):
+            raise OSError(errno.EACCES, "EACCES")
+
+        self.create_regular_file("file")
+        xattr.setxattr(b"input/file", b"user.attribute%p", b"value")
+        self.cmd(f"--repo={self.repository_location}", "rcreate", "-e" "none")
+        self.cmd(f"--repo={self.repository_location}", "create", "test", "input")
+        with changedir("output"):
+            with patch.object(xattr, "setxattr", patched_setxattr_EACCES):
+                self.cmd(f"--repo={self.repository_location}", "extract", "test", exit_code=EXIT_WARNING)
 
     # derived from test_extract_xattrs_errors()
-    @pytest.mark.skipif(not xattr.XATTR_FAKEROOT, reason='xattr not supported on this system or on this version of'
-                                                         'fakeroot')
+    @pytest.mark.skipif(
+        not xattr.XATTR_FAKEROOT, reason="xattr not supported on this system or on this version of" "fakeroot"
+    )
     def test_do_not_fail_when_percent_is_in_file_name(self):
         """https://github.com/borgbackup/borg/issues/6063"""
-        def patched_setxattr_EACCES(*args, **kwargs):
-            raise OSError(errno.EACCES, 'EACCES')
 
-        os.makedirs(os.path.join(self.input_path, 'dir%p'))
-        xattr.setxattr(b'input/dir%p', b'user.attribute', b'value')
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', '-e' 'none')
-        self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
-        with changedir('output'):
-            with patch.object(xattr, 'setxattr', patched_setxattr_EACCES):
-                self.cmd(f'--repo={self.repository_location}', 'extract', 'test', exit_code=EXIT_WARNING)
+        def patched_setxattr_EACCES(*args, **kwargs):
+            raise OSError(errno.EACCES, "EACCES")
+
+        os.makedirs(os.path.join(self.input_path, "dir%p"))
+        xattr.setxattr(b"input/dir%p", b"user.attribute", b"value")
+        self.cmd(f"--repo={self.repository_location}", "rcreate", "-e" "none")
+        self.cmd(f"--repo={self.repository_location}", "create", "test", "input")
+        with changedir("output"):
+            with patch.object(xattr, "setxattr", patched_setxattr_EACCES):
+                self.cmd(f"--repo={self.repository_location}", "extract", "test", exit_code=EXIT_WARNING)
 
     def test_do_not_mention_archive_if_you_can_not_find_repo(self):
         """https://github.com/borgbackup/borg/issues/6014"""
-        output = self.cmd(f'--repo={self.repository_location}-this-repository-does-not-exist', 'info', '-a', 'test',
-                          exit_code=2, fork=True)
-        self.assert_in('this-repository-does-not-exist', output)
-        self.assert_not_in('this-repository-does-not-exist::test', output)
+        output = self.cmd(
+            f"--repo={self.repository_location}-this-repository-does-not-exist",
+            "info",
+            "-a",
+            "test",
+            exit_code=2,
+            fork=True,
+        )
+        self.assert_in("this-repository-does-not-exist", output)
+        self.assert_not_in("this-repository-does-not-exist::test", output)
 
     def test_init_defaults_to_argon2(self):
         """https://github.com/borgbackup/borg/issues/747#issuecomment-1076160401"""
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
+        self.cmd(f"--repo={self.repository_location}", "rcreate", RK_ENCRYPTION)
         with Repository(self.repository_path) as repository:
             key = msgpack.unpackb(a2b_base64(repository.load_key()))
-        assert key['algorithm'] == 'argon2 chacha20-poly1305'
+        assert key["algorithm"] == "argon2 chacha20-poly1305"
 
     def test_change_passphrase_does_not_change_algorithm_argon2(self):
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
-        os.environ['BORG_NEW_PASSPHRASE'] = 'newpassphrase'
+        self.cmd(f"--repo={self.repository_location}", "rcreate", RK_ENCRYPTION)
+        os.environ["BORG_NEW_PASSPHRASE"] = "newpassphrase"
 
-        self.cmd(f'--repo={self.repository_location}', 'key', 'change-passphrase')
+        self.cmd(f"--repo={self.repository_location}", "key", "change-passphrase")
 
         with Repository(self.repository_path) as repository:
             key = msgpack.unpackb(a2b_base64(repository.load_key()))
-            assert key['algorithm'] == 'argon2 chacha20-poly1305'
+            assert key["algorithm"] == "argon2 chacha20-poly1305"
 
     def test_change_location_does_not_change_algorithm_argon2(self):
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', KF_ENCRYPTION)
+        self.cmd(f"--repo={self.repository_location}", "rcreate", KF_ENCRYPTION)
 
-        self.cmd(f'--repo={self.repository_location}', 'key', 'change-location', 'repokey')
+        self.cmd(f"--repo={self.repository_location}", "key", "change-location", "repokey")
 
         with Repository(self.repository_path) as repository:
             key = msgpack.unpackb(a2b_base64(repository.load_key()))
-            assert key['algorithm'] == 'argon2 chacha20-poly1305'
+            assert key["algorithm"] == "argon2 chacha20-poly1305"
 
 
-@unittest.skipUnless('binary' in BORG_EXES, 'no borg.exe available')
+@unittest.skipUnless("binary" in BORG_EXES, "no borg.exe available")
 class ArchiverTestCaseBinary(ArchiverTestCase):
-    EXE = 'borg.exe'
+    EXE = "borg.exe"
     FORK_DEFAULT = True
 
-    @unittest.skip('does not raise Exception, but sets rc==2')
+    @unittest.skip("does not raise Exception, but sets rc==2")
     def test_init_parent_dirs(self):
         pass
 
-    @unittest.skip('patches objects')
+    @unittest.skip("patches objects")
     def test_init_interrupt(self):
         pass
 
-    @unittest.skip('patches objects')
+    @unittest.skip("patches objects")
     def test_extract_capabilities(self):
         pass
 
-    @unittest.skip('patches objects')
+    @unittest.skip("patches objects")
     def test_extract_xattrs_errors(self):
         pass
 
-    @unittest.skip('test_basic_functionality seems incompatible with fakeroot and/or the binary.')
+    @unittest.skip("test_basic_functionality seems incompatible with fakeroot and/or the binary.")
     def test_basic_functionality(self):
         pass
 
-    @unittest.skip('test_overwrite seems incompatible with fakeroot and/or the binary.')
+    @unittest.skip("test_overwrite seems incompatible with fakeroot and/or the binary.")
     def test_overwrite(self):
         pass
 
     def test_fuse(self):
         if fakeroot_detected():
-            unittest.skip('test_fuse with the binary is not compatible with fakeroot')
+            unittest.skip("test_fuse with the binary is not compatible with fakeroot")
         else:
             super().test_fuse()
 
-    @unittest.skip('patches objects')
+    @unittest.skip("patches objects")
     def test_do_not_fail_when_percent_is_in_xattr_name(self):
         pass
 
-    @unittest.skip('patches objects')
+    @unittest.skip("patches objects")
     def test_do_not_fail_when_percent_is_in_file_name(self):
         pass
 
 
 class ArchiverCheckTestCase(ArchiverTestCaseBase):
-
     def setUp(self):
         super().setUp()
-        with patch.object(ChunkBuffer, 'BUFFER_SIZE', 10):
-            self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
-            self.create_src_archive('archive1')
-            self.create_src_archive('archive2')
+        with patch.object(ChunkBuffer, "BUFFER_SIZE", 10):
+            self.cmd(f"--repo={self.repository_location}", "rcreate", RK_ENCRYPTION)
+            self.create_src_archive("archive1")
+            self.create_src_archive("archive2")
 
     def test_check_usage(self):
-        output = self.cmd(f'--repo={self.repository_location}', 'check', '-v', '--progress', exit_code=0)
-        self.assert_in('Starting repository check', output)
-        self.assert_in('Starting archive consistency check', output)
-        self.assert_in('Checking segments', output)
+        output = self.cmd(f"--repo={self.repository_location}", "check", "-v", "--progress", exit_code=0)
+        self.assert_in("Starting repository check", output)
+        self.assert_in("Starting archive consistency check", output)
+        self.assert_in("Checking segments", output)
         # reset logging to new process default to avoid need for fork=True on next check
-        logging.getLogger('borg.output.progress').setLevel(logging.NOTSET)
-        output = self.cmd(f'--repo={self.repository_location}', 'check', '-v', '--repository-only', exit_code=0)
-        self.assert_in('Starting repository check', output)
-        self.assert_not_in('Starting archive consistency check', output)
-        self.assert_not_in('Checking segments', output)
-        output = self.cmd(f'--repo={self.repository_location}', 'check', '-v', '--archives-only', exit_code=0)
-        self.assert_not_in('Starting repository check', output)
-        self.assert_in('Starting archive consistency check', output)
-        output = self.cmd(f'--repo={self.repository_location}', 'check', '-v', '--archives-only', '--glob-archives=archive2', exit_code=0)
-        self.assert_not_in('archive1', output)
-        output = self.cmd(f'--repo={self.repository_location}', 'check', '-v', '--archives-only', '--first=1', exit_code=0)
-        self.assert_in('archive1', output)
-        self.assert_not_in('archive2', output)
-        output = self.cmd(f'--repo={self.repository_location}', 'check', '-v', '--archives-only', '--last=1', exit_code=0)
-        self.assert_not_in('archive1', output)
-        self.assert_in('archive2', output)
+        logging.getLogger("borg.output.progress").setLevel(logging.NOTSET)
+        output = self.cmd(f"--repo={self.repository_location}", "check", "-v", "--repository-only", exit_code=0)
+        self.assert_in("Starting repository check", output)
+        self.assert_not_in("Starting archive consistency check", output)
+        self.assert_not_in("Checking segments", output)
+        output = self.cmd(f"--repo={self.repository_location}", "check", "-v", "--archives-only", exit_code=0)
+        self.assert_not_in("Starting repository check", output)
+        self.assert_in("Starting archive consistency check", output)
+        output = self.cmd(
+            f"--repo={self.repository_location}",
+            "check",
+            "-v",
+            "--archives-only",
+            "--glob-archives=archive2",
+            exit_code=0,
+        )
+        self.assert_not_in("archive1", output)
+        output = self.cmd(
+            f"--repo={self.repository_location}", "check", "-v", "--archives-only", "--first=1", exit_code=0
+        )
+        self.assert_in("archive1", output)
+        self.assert_not_in("archive2", output)
+        output = self.cmd(
+            f"--repo={self.repository_location}", "check", "-v", "--archives-only", "--last=1", exit_code=0
+        )
+        self.assert_not_in("archive1", output)
+        self.assert_in("archive2", output)
 
     def test_missing_file_chunk(self):
-        archive, repository = self.open_archive('archive1')
+        archive, repository = self.open_archive("archive1")
         with repository:
             for item in archive.iter_items():
-                if item.path.endswith('testsuite/archiver.py'):
+                if item.path.endswith("testsuite/archiver.py"):
                     valid_chunks = item.chunks
                     killed_chunk = valid_chunks[-1]
                     repository.delete(killed_chunk.id)
                     break
             else:
-                self.fail('should not happen')
+                self.fail("should not happen")
             repository.commit(compact=False)
-        self.cmd(f'--repo={self.repository_location}', 'check', exit_code=1)
-        output = self.cmd(f'--repo={self.repository_location}', 'check', '--repair', exit_code=0)
-        self.assert_in('New missing file chunk detected', output)
-        self.cmd(f'--repo={self.repository_location}', 'check', exit_code=0)
-        output = self.cmd(f'--repo={self.repository_location}', 'list', 'archive1', '--format={health}#{path}{LF}', exit_code=0)
-        self.assert_in('broken#', output)
+        self.cmd(f"--repo={self.repository_location}", "check", exit_code=1)
+        output = self.cmd(f"--repo={self.repository_location}", "check", "--repair", exit_code=0)
+        self.assert_in("New missing file chunk detected", output)
+        self.cmd(f"--repo={self.repository_location}", "check", exit_code=0)
+        output = self.cmd(
+            f"--repo={self.repository_location}", "list", "archive1", "--format={health}#{path}{LF}", exit_code=0
+        )
+        self.assert_in("broken#", output)
         # check that the file in the old archives has now a different chunk list without the killed chunk
-        for archive_name in ('archive1', 'archive2'):
+        for archive_name in ("archive1", "archive2"):
             archive, repository = self.open_archive(archive_name)
             with repository:
                 for item in archive.iter_items():
-                    if item.path.endswith('testsuite/archiver.py'):
+                    if item.path.endswith("testsuite/archiver.py"):
                         self.assert_not_equal(valid_chunks, item.chunks)
                         self.assert_not_in(killed_chunk, item.chunks)
                         break
                 else:
-                    self.fail('should not happen')
+                    self.fail("should not happen")
         # do a fresh backup (that will include the killed chunk)
-        with patch.object(ChunkBuffer, 'BUFFER_SIZE', 10):
-            self.create_src_archive('archive3')
+        with patch.object(ChunkBuffer, "BUFFER_SIZE", 10):
+            self.create_src_archive("archive3")
         # check should be able to heal the file now:
-        output = self.cmd(f'--repo={self.repository_location}', 'check', '-v', '--repair', exit_code=0)
-        self.assert_in('Healed previously missing file chunk', output)
-        self.assert_in('testsuite/archiver.py: Completely healed previously damaged file!', output)
+        output = self.cmd(f"--repo={self.repository_location}", "check", "-v", "--repair", exit_code=0)
+        self.assert_in("Healed previously missing file chunk", output)
+        self.assert_in("testsuite/archiver.py: Completely healed previously damaged file!", output)
         # check that the file in the old archives has the correct chunks again
-        for archive_name in ('archive1', 'archive2'):
+        for archive_name in ("archive1", "archive2"):
             archive, repository = self.open_archive(archive_name)
             with repository:
                 for item in archive.iter_items():
-                    if item.path.endswith('testsuite/archiver.py'):
+                    if item.path.endswith("testsuite/archiver.py"):
                         self.assert_equal(valid_chunks, item.chunks)
                         break
                 else:
-                    self.fail('should not happen')
+                    self.fail("should not happen")
         # list is also all-healthy again
-        output = self.cmd(f'--repo={self.repository_location}', 'list', 'archive1', '--format={health}#{path}{LF}', exit_code=0)
-        self.assert_not_in('broken#', output)
+        output = self.cmd(
+            f"--repo={self.repository_location}", "list", "archive1", "--format={health}#{path}{LF}", exit_code=0
+        )
+        self.assert_not_in("broken#", output)
 
     def test_missing_archive_item_chunk(self):
-        archive, repository = self.open_archive('archive1')
+        archive, repository = self.open_archive("archive1")
         with repository:
             repository.delete(archive.metadata.items[0])
             repository.commit(compact=False)
-        self.cmd(f'--repo={self.repository_location}', 'check', exit_code=1)
-        self.cmd(f'--repo={self.repository_location}', 'check', '--repair', exit_code=0)
-        self.cmd(f'--repo={self.repository_location}', 'check', exit_code=0)
+        self.cmd(f"--repo={self.repository_location}", "check", exit_code=1)
+        self.cmd(f"--repo={self.repository_location}", "check", "--repair", exit_code=0)
+        self.cmd(f"--repo={self.repository_location}", "check", exit_code=0)
 
     def test_missing_archive_metadata(self):
-        archive, repository = self.open_archive('archive1')
+        archive, repository = self.open_archive("archive1")
         with repository:
             repository.delete(archive.id)
             repository.commit(compact=False)
-        self.cmd(f'--repo={self.repository_location}', 'check', exit_code=1)
-        self.cmd(f'--repo={self.repository_location}', 'check', '--repair', exit_code=0)
-        self.cmd(f'--repo={self.repository_location}', 'check', exit_code=0)
+        self.cmd(f"--repo={self.repository_location}", "check", exit_code=1)
+        self.cmd(f"--repo={self.repository_location}", "check", "--repair", exit_code=0)
+        self.cmd(f"--repo={self.repository_location}", "check", exit_code=0)
 
     def test_missing_manifest(self):
-        archive, repository = self.open_archive('archive1')
+        archive, repository = self.open_archive("archive1")
         with repository:
             repository.delete(Manifest.MANIFEST_ID)
             repository.commit(compact=False)
-        self.cmd(f'--repo={self.repository_location}', 'check', exit_code=1)
-        output = self.cmd(f'--repo={self.repository_location}', 'check', '-v', '--repair', exit_code=0)
-        self.assert_in('archive1', output)
-        self.assert_in('archive2', output)
-        self.cmd(f'--repo={self.repository_location}', 'check', exit_code=0)
+        self.cmd(f"--repo={self.repository_location}", "check", exit_code=1)
+        output = self.cmd(f"--repo={self.repository_location}", "check", "-v", "--repair", exit_code=0)
+        self.assert_in("archive1", output)
+        self.assert_in("archive2", output)
+        self.cmd(f"--repo={self.repository_location}", "check", exit_code=0)
 
     def test_corrupted_manifest(self):
-        archive, repository = self.open_archive('archive1')
+        archive, repository = self.open_archive("archive1")
         with repository:
             manifest = repository.get(Manifest.MANIFEST_ID)
-            corrupted_manifest = manifest + b'corrupted!'
+            corrupted_manifest = manifest + b"corrupted!"
             repository.put(Manifest.MANIFEST_ID, corrupted_manifest)
             repository.commit(compact=False)
-        self.cmd(f'--repo={self.repository_location}', 'check', exit_code=1)
-        output = self.cmd(f'--repo={self.repository_location}', 'check', '-v', '--repair', exit_code=0)
-        self.assert_in('archive1', output)
-        self.assert_in('archive2', output)
-        self.cmd(f'--repo={self.repository_location}', 'check', exit_code=0)
+        self.cmd(f"--repo={self.repository_location}", "check", exit_code=1)
+        output = self.cmd(f"--repo={self.repository_location}", "check", "-v", "--repair", exit_code=0)
+        self.assert_in("archive1", output)
+        self.assert_in("archive2", output)
+        self.cmd(f"--repo={self.repository_location}", "check", exit_code=0)
 
     def test_manifest_rebuild_corrupted_chunk(self):
-        archive, repository = self.open_archive('archive1')
+        archive, repository = self.open_archive("archive1")
         with repository:
             manifest = repository.get(Manifest.MANIFEST_ID)
-            corrupted_manifest = manifest + b'corrupted!'
+            corrupted_manifest = manifest + b"corrupted!"
             repository.put(Manifest.MANIFEST_ID, corrupted_manifest)
 
             chunk = repository.get(archive.id)
-            corrupted_chunk = chunk + b'corrupted!'
+            corrupted_chunk = chunk + b"corrupted!"
             repository.put(archive.id, corrupted_chunk)
             repository.commit(compact=False)
-        self.cmd(f'--repo={self.repository_location}', 'check', exit_code=1)
-        output = self.cmd(f'--repo={self.repository_location}', 'check', '-v', '--repair', exit_code=0)
-        self.assert_in('archive2', output)
-        self.cmd(f'--repo={self.repository_location}', 'check', exit_code=0)
+        self.cmd(f"--repo={self.repository_location}", "check", exit_code=1)
+        output = self.cmd(f"--repo={self.repository_location}", "check", "-v", "--repair", exit_code=0)
+        self.assert_in("archive2", output)
+        self.cmd(f"--repo={self.repository_location}", "check", exit_code=0)
 
     def test_manifest_rebuild_duplicate_archive(self):
-        archive, repository = self.open_archive('archive1')
+        archive, repository = self.open_archive("archive1")
         key = archive.key
         with repository:
             manifest = repository.get(Manifest.MANIFEST_ID)
-            corrupted_manifest = manifest + b'corrupted!'
+            corrupted_manifest = manifest + b"corrupted!"
             repository.put(Manifest.MANIFEST_ID, corrupted_manifest)
 
-            archive = msgpack.packb({
-                'cmdline': [],
-                'items': [],
-                'hostname': 'foo',
-                'username': 'bar',
-                'name': 'archive1',
-                'time': '2016-12-15T18:49:51.849711',
-                'version': 2,
-            })
+            archive = msgpack.packb(
+                {
+                    "cmdline": [],
+                    "items": [],
+                    "hostname": "foo",
+                    "username": "bar",
+                    "name": "archive1",
+                    "time": "2016-12-15T18:49:51.849711",
+                    "version": 2,
+                }
+            )
             archive_id = key.id_hash(archive)
             repository.put(archive_id, key.encrypt(archive_id, archive))
             repository.commit(compact=False)
-        self.cmd(f'--repo={self.repository_location}', 'check', exit_code=1)
-        self.cmd(f'--repo={self.repository_location}', 'check', '--repair', exit_code=0)
-        output = self.cmd(f'--repo={self.repository_location}', 'rlist')
-        self.assert_in('archive1', output)
-        self.assert_in('archive1.1', output)
-        self.assert_in('archive2', output)
+        self.cmd(f"--repo={self.repository_location}", "check", exit_code=1)
+        self.cmd(f"--repo={self.repository_location}", "check", "--repair", exit_code=0)
+        output = self.cmd(f"--repo={self.repository_location}", "rlist")
+        self.assert_in("archive1", output)
+        self.assert_in("archive1.1", output)
+        self.assert_in("archive2", output)
 
     def test_extra_chunks(self):
-        self.cmd(f'--repo={self.repository_location}', 'check', exit_code=0)
+        self.cmd(f"--repo={self.repository_location}", "check", exit_code=0)
         with Repository(self.repository_location, exclusive=True) as repository:
-            repository.put(b'01234567890123456789012345678901', b'xxxx')
+            repository.put(b"01234567890123456789012345678901", b"xxxx")
             repository.commit(compact=False)
-        self.cmd(f'--repo={self.repository_location}', 'check', exit_code=1)
-        self.cmd(f'--repo={self.repository_location}', 'check', exit_code=1)
-        self.cmd(f'--repo={self.repository_location}', 'check', '--repair', exit_code=0)
-        self.cmd(f'--repo={self.repository_location}', 'check', exit_code=0)
-        self.cmd(f'--repo={self.repository_location}', 'extract', 'archive1', '--dry-run', exit_code=0)
+        self.cmd(f"--repo={self.repository_location}", "check", exit_code=1)
+        self.cmd(f"--repo={self.repository_location}", "check", exit_code=1)
+        self.cmd(f"--repo={self.repository_location}", "check", "--repair", exit_code=0)
+        self.cmd(f"--repo={self.repository_location}", "check", exit_code=0)
+        self.cmd(f"--repo={self.repository_location}", "extract", "archive1", "--dry-run", exit_code=0)
 
     def _test_verify_data(self, *init_args):
         shutil.rmtree(self.repository_path)
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', *init_args)
-        self.create_src_archive('archive1')
-        archive, repository = self.open_archive('archive1')
+        self.cmd(f"--repo={self.repository_location}", "rcreate", *init_args)
+        self.create_src_archive("archive1")
+        archive, repository = self.open_archive("archive1")
         with repository:
             for item in archive.iter_items():
-                if item.path.endswith('testsuite/archiver.py'):
+                if item.path.endswith("testsuite/archiver.py"):
                     chunk = item.chunks[-1]
-                    data = repository.get(chunk.id) + b'1234'
+                    data = repository.get(chunk.id) + b"1234"
                     repository.put(chunk.id, data)
                     break
             repository.commit(compact=False)
-        self.cmd(f'--repo={self.repository_location}', 'check', exit_code=0)
-        output = self.cmd(f'--repo={self.repository_location}', 'check', '--verify-data', exit_code=1)
-        assert bin_to_hex(chunk.id) + ', integrity error' in output
+        self.cmd(f"--repo={self.repository_location}", "check", exit_code=0)
+        output = self.cmd(f"--repo={self.repository_location}", "check", "--verify-data", exit_code=1)
+        assert bin_to_hex(chunk.id) + ", integrity error" in output
         # repair (heal is tested in another test)
-        output = self.cmd(f'--repo={self.repository_location}', 'check', '--repair', '--verify-data', exit_code=0)
-        assert bin_to_hex(chunk.id) + ', integrity error' in output
-        assert 'testsuite/archiver.py: New missing file chunk detected' in output
+        output = self.cmd(f"--repo={self.repository_location}", "check", "--repair", "--verify-data", exit_code=0)
+        assert bin_to_hex(chunk.id) + ", integrity error" in output
+        assert "testsuite/archiver.py: New missing file chunk detected" in output
 
     def test_verify_data(self):
         self._test_verify_data(RK_ENCRYPTION)
 
     def test_verify_data_unencrypted(self):
-        self._test_verify_data('--encryption', 'none')
+        self._test_verify_data("--encryption", "none")
 
     def test_empty_repository(self):
         with Repository(self.repository_location, exclusive=True) as repository:
             for id_ in repository.list():
                 repository.delete(id_)
             repository.commit(compact=False)
-        self.cmd(f'--repo={self.repository_location}', 'check', exit_code=1)
+        self.cmd(f"--repo={self.repository_location}", "check", exit_code=1)
 
 
 class ManifestAuthenticationTest(ArchiverTestCaseBase):
     def spoof_manifest(self, repository):
         with repository:
             _, key = Manifest.load(repository, Manifest.NO_OPERATION_CHECK)
-            repository.put(Manifest.MANIFEST_ID, key.encrypt(Manifest.MANIFEST_ID, msgpack.packb({
-                'version': 1,
-                'archives': {},
-                'config': {},
-                'timestamp': (datetime.utcnow() + timedelta(days=1)).strftime(ISO_FORMAT),
-            })))
+            repository.put(
+                Manifest.MANIFEST_ID,
+                key.encrypt(
+                    Manifest.MANIFEST_ID,
+                    msgpack.packb(
+                        {
+                            "version": 1,
+                            "archives": {},
+                            "config": {},
+                            "timestamp": (datetime.utcnow() + timedelta(days=1)).strftime(ISO_FORMAT),
+                        }
+                    ),
+                ),
+            )
             repository.commit(compact=False)
 
     def test_fresh_init_tam_required(self):
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
+        self.cmd(f"--repo={self.repository_location}", "rcreate", RK_ENCRYPTION)
         repository = Repository(self.repository_path, exclusive=True)
         with repository:
             manifest, key = Manifest.load(repository, Manifest.NO_OPERATION_CHECK)
-            repository.put(Manifest.MANIFEST_ID, key.encrypt(Manifest.MANIFEST_ID, msgpack.packb({
-                'version': 1,
-                'archives': {},
-                'timestamp': (datetime.utcnow() + timedelta(days=1)).strftime(ISO_FORMAT),
-            })))
+            repository.put(
+                Manifest.MANIFEST_ID,
+                key.encrypt(
+                    Manifest.MANIFEST_ID,
+                    msgpack.packb(
+                        {
+                            "version": 1,
+                            "archives": {},
+                            "timestamp": (datetime.utcnow() + timedelta(days=1)).strftime(ISO_FORMAT),
+                        }
+                    ),
+                ),
+            )
             repository.commit(compact=False)
 
         with pytest.raises(TAMRequiredError):
-            self.cmd(f'--repo={self.repository_location}', 'rlist')
+            self.cmd(f"--repo={self.repository_location}", "rlist")
 
     def test_not_required(self):
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
-        self.create_src_archive('archive1234')
+        self.cmd(f"--repo={self.repository_location}", "rcreate", RK_ENCRYPTION)
+        self.create_src_archive("archive1234")
         repository = Repository(self.repository_path, exclusive=True)
         # Manifest must be authenticated now
-        output = self.cmd(f'--repo={self.repository_location}', 'rlist', '--debug')
-        assert 'archive1234' in output
-        assert 'TAM-verified manifest' in output
+        output = self.cmd(f"--repo={self.repository_location}", "rlist", "--debug")
+        assert "archive1234" in output
+        assert "TAM-verified manifest" in output
         # Try to spoof / modify pre-1.0.9
         self.spoof_manifest(repository)
         # Fails
         with pytest.raises(TAMRequiredError):
-            self.cmd(f'--repo={self.repository_location}', 'rlist')
+            self.cmd(f"--repo={self.repository_location}", "rlist")
 
 
 class RemoteArchiverTestCase(ArchiverTestCase):
-    prefix = 'ssh://__testsuite__'
+    prefix = "ssh://__testsuite__"
 
     def open_repository(self):
         return RemoteRepository(Location(self.repository_location))
 
     def test_remote_repo_restrict_to_path(self):
         # restricted to repo directory itself:
-        with patch.object(RemoteRepository, 'extra_test_args', ['--restrict-to-path', self.repository_path]):
-            self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
+        with patch.object(RemoteRepository, "extra_test_args", ["--restrict-to-path", self.repository_path]):
+            self.cmd(f"--repo={self.repository_location}", "rcreate", RK_ENCRYPTION)
         # restricted to repo directory itself, fail for other directories with same prefix:
-        with patch.object(RemoteRepository, 'extra_test_args', ['--restrict-to-path', self.repository_path]):
+        with patch.object(RemoteRepository, "extra_test_args", ["--restrict-to-path", self.repository_path]):
             with pytest.raises(PathNotAllowed):
-                self.cmd(f'--repo={self.repository_location}_0', 'rcreate', RK_ENCRYPTION)
+                self.cmd(f"--repo={self.repository_location}_0", "rcreate", RK_ENCRYPTION)
 
         # restricted to a completely different path:
-        with patch.object(RemoteRepository, 'extra_test_args', ['--restrict-to-path', '/foo']):
+        with patch.object(RemoteRepository, "extra_test_args", ["--restrict-to-path", "/foo"]):
             with pytest.raises(PathNotAllowed):
-                self.cmd(f'--repo={self.repository_location}_1', 'rcreate', RK_ENCRYPTION)
+                self.cmd(f"--repo={self.repository_location}_1", "rcreate", RK_ENCRYPTION)
         path_prefix = os.path.dirname(self.repository_path)
         # restrict to repo directory's parent directory:
-        with patch.object(RemoteRepository, 'extra_test_args', ['--restrict-to-path', path_prefix]):
-            self.cmd(f'--repo={self.repository_location}_2', 'rcreate', RK_ENCRYPTION)
+        with patch.object(RemoteRepository, "extra_test_args", ["--restrict-to-path", path_prefix]):
+            self.cmd(f"--repo={self.repository_location}_2", "rcreate", RK_ENCRYPTION)
         # restrict to repo directory's parent directory and another directory:
-        with patch.object(RemoteRepository, 'extra_test_args', ['--restrict-to-path', '/foo', '--restrict-to-path', path_prefix]):
-            self.cmd(f'--repo={self.repository_location}_3', 'rcreate', RK_ENCRYPTION)
+        with patch.object(
+            RemoteRepository, "extra_test_args", ["--restrict-to-path", "/foo", "--restrict-to-path", path_prefix]
+        ):
+            self.cmd(f"--repo={self.repository_location}_3", "rcreate", RK_ENCRYPTION)
 
     def test_remote_repo_restrict_to_repository(self):
         # restricted to repo directory itself:
-        with patch.object(RemoteRepository, 'extra_test_args', ['--restrict-to-repository', self.repository_path]):
-            self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
-        parent_path = os.path.join(self.repository_path, '..')
-        with patch.object(RemoteRepository, 'extra_test_args', ['--restrict-to-repository', parent_path]):
+        with patch.object(RemoteRepository, "extra_test_args", ["--restrict-to-repository", self.repository_path]):
+            self.cmd(f"--repo={self.repository_location}", "rcreate", RK_ENCRYPTION)
+        parent_path = os.path.join(self.repository_path, "..")
+        with patch.object(RemoteRepository, "extra_test_args", ["--restrict-to-repository", parent_path]):
             with pytest.raises(PathNotAllowed):
-                self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
+                self.cmd(f"--repo={self.repository_location}", "rcreate", RK_ENCRYPTION)
 
-    @unittest.skip('only works locally')
+    @unittest.skip("only works locally")
     def test_debug_put_get_delete_obj(self):
         pass
 
-    @unittest.skip('only works locally')
+    @unittest.skip("only works locally")
     def test_config(self):
         pass
 
-    @unittest.skip('only works locally')
+    @unittest.skip("only works locally")
     def test_migrate_lock_alive(self):
         pass
 
     def test_remote_repo_strip_components_doesnt_leak(self):
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
-        self.create_regular_file('dir/file', contents=b"test file contents 1")
-        self.create_regular_file('dir/file2', contents=b"test file contents 2")
-        self.create_regular_file('skipped-file1', contents=b"test file contents 3")
-        self.create_regular_file('skipped-file2', contents=b"test file contents 4")
-        self.create_regular_file('skipped-file3', contents=b"test file contents 5")
-        self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
-        marker = 'cached responses left in RemoteRepository'
-        with changedir('output'):
-            res = self.cmd(f'--repo={self.repository_location}', 'extract', 'test', "--debug", '--strip-components', '3')
+        self.cmd(f"--repo={self.repository_location}", "rcreate", RK_ENCRYPTION)
+        self.create_regular_file("dir/file", contents=b"test file contents 1")
+        self.create_regular_file("dir/file2", contents=b"test file contents 2")
+        self.create_regular_file("skipped-file1", contents=b"test file contents 3")
+        self.create_regular_file("skipped-file2", contents=b"test file contents 4")
+        self.create_regular_file("skipped-file3", contents=b"test file contents 5")
+        self.cmd(f"--repo={self.repository_location}", "create", "test", "input")
+        marker = "cached responses left in RemoteRepository"
+        with changedir("output"):
+            res = self.cmd(
+                f"--repo={self.repository_location}", "extract", "test", "--debug", "--strip-components", "3"
+            )
             assert marker not in res
-            with self.assert_creates_file('file'):
-                res = self.cmd(f'--repo={self.repository_location}', 'extract', 'test', "--debug", '--strip-components', '2')
+            with self.assert_creates_file("file"):
+                res = self.cmd(
+                    f"--repo={self.repository_location}", "extract", "test", "--debug", "--strip-components", "2"
+                )
                 assert marker not in res
-            with self.assert_creates_file('dir/file'):
-                res = self.cmd(f'--repo={self.repository_location}', 'extract', 'test', "--debug", '--strip-components', '1')
+            with self.assert_creates_file("dir/file"):
+                res = self.cmd(
+                    f"--repo={self.repository_location}", "extract", "test", "--debug", "--strip-components", "1"
+                )
                 assert marker not in res
-            with self.assert_creates_file('input/dir/file'):
-                res = self.cmd(f'--repo={self.repository_location}', 'extract', 'test', "--debug", '--strip-components', '0')
+            with self.assert_creates_file("input/dir/file"):
+                res = self.cmd(
+                    f"--repo={self.repository_location}", "extract", "test", "--debug", "--strip-components", "0"
+                )
                 assert marker not in res
 
 
@@ -3864,313 +4187,317 @@ class ArchiverCorruptionTestCase(ArchiverTestCaseBase):
     def setUp(self):
         super().setUp()
         self.create_test_files()
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
-        self.cache_path = json.loads(self.cmd(f'--repo={self.repository_location}', 'rinfo', '--json'))['cache']['path']
+        self.cmd(f"--repo={self.repository_location}", "rcreate", RK_ENCRYPTION)
+        self.cache_path = json.loads(self.cmd(f"--repo={self.repository_location}", "rinfo", "--json"))["cache"]["path"]
 
     def corrupt(self, file, amount=1):
-        with open(file, 'r+b') as fd:
+        with open(file, "r+b") as fd:
             fd.seek(-amount, io.SEEK_END)
-            corrupted = bytes(255-c for c in fd.read(amount))
+            corrupted = bytes(255 - c for c in fd.read(amount))
             fd.seek(-amount, io.SEEK_END)
             fd.write(corrupted)
 
     def test_cache_chunks(self):
-        self.corrupt(os.path.join(self.cache_path, 'chunks'))
+        self.corrupt(os.path.join(self.cache_path, "chunks"))
 
         if self.FORK_DEFAULT:
-            out = self.cmd(f'--repo={self.repository_location}', 'rinfo', exit_code=2)
-            assert 'failed integrity check' in out
+            out = self.cmd(f"--repo={self.repository_location}", "rinfo", exit_code=2)
+            assert "failed integrity check" in out
         else:
             with pytest.raises(FileIntegrityError):
-                self.cmd(f'--repo={self.repository_location}', 'rinfo')
+                self.cmd(f"--repo={self.repository_location}", "rinfo")
 
     def test_cache_files(self):
-        self.cmd(f'--repo={self.repository_location}', 'create', 'test', 'input')
-        self.corrupt(os.path.join(self.cache_path, 'files'))
-        out = self.cmd(f'--repo={self.repository_location}', 'create', 'test1', 'input')
+        self.cmd(f"--repo={self.repository_location}", "create", "test", "input")
+        self.corrupt(os.path.join(self.cache_path, "files"))
+        out = self.cmd(f"--repo={self.repository_location}", "create", "test1", "input")
         # borg warns about the corrupt files cache, but then continues without files cache.
-        assert 'files cache is corrupted' in out
+        assert "files cache is corrupted" in out
 
     def test_chunks_archive(self):
-        self.cmd(f'--repo={self.repository_location}', 'create', 'test1', 'input')
+        self.cmd(f"--repo={self.repository_location}", "create", "test1", "input")
         # Find ID of test1 so we can corrupt it later :)
-        target_id = self.cmd(f'--repo={self.repository_location}', 'rlist', '--format={id}{LF}').strip()
-        self.cmd(f'--repo={self.repository_location}', 'create', 'test2', 'input')
+        target_id = self.cmd(f"--repo={self.repository_location}", "rlist", "--format={id}{LF}").strip()
+        self.cmd(f"--repo={self.repository_location}", "create", "test2", "input")
 
         # Force cache sync, creating archive chunks of test1 and test2 in chunks.archive.d
-        self.cmd(f'--repo={self.repository_location}', 'rdelete', '--cache-only')
-        self.cmd(f'--repo={self.repository_location}', 'rinfo', '--json')
+        self.cmd(f"--repo={self.repository_location}", "rdelete", "--cache-only")
+        self.cmd(f"--repo={self.repository_location}", "rinfo", "--json")
 
-        chunks_archive = os.path.join(self.cache_path, 'chunks.archive.d')
+        chunks_archive = os.path.join(self.cache_path, "chunks.archive.d")
         assert len(os.listdir(chunks_archive)) == 4  # two archives, one chunks cache and one .integrity file each
 
-        self.corrupt(os.path.join(chunks_archive, target_id + '.compact'))
+        self.corrupt(os.path.join(chunks_archive, target_id + ".compact"))
 
         # Trigger cache sync by changing the manifest ID in the cache config
-        config_path = os.path.join(self.cache_path, 'config')
+        config_path = os.path.join(self.cache_path, "config")
         config = ConfigParser(interpolation=None)
         config.read(config_path)
-        config.set('cache', 'manifest', bin_to_hex(bytes(32)))
-        with open(config_path, 'w') as fd:
+        config.set("cache", "manifest", bin_to_hex(bytes(32)))
+        with open(config_path, "w") as fd:
             config.write(fd)
 
         # Cache sync notices corrupted archive chunks, but automatically recovers.
-        out = self.cmd(f'--repo={self.repository_location}', 'create', '-v', 'test3', 'input', exit_code=1)
-        assert 'Reading cached archive chunk index for test1' in out
-        assert 'Cached archive chunk index of test1 is corrupted' in out
-        assert 'Fetching and building archive index for test1' in out
+        out = self.cmd(f"--repo={self.repository_location}", "create", "-v", "test3", "input", exit_code=1)
+        assert "Reading cached archive chunk index for test1" in out
+        assert "Cached archive chunk index of test1 is corrupted" in out
+        assert "Fetching and building archive index for test1" in out
 
     def test_old_version_interfered(self):
         # Modify the main manifest ID without touching the manifest ID in the integrity section.
         # This happens if a version without integrity checking modifies the cache.
-        config_path = os.path.join(self.cache_path, 'config')
+        config_path = os.path.join(self.cache_path, "config")
         config = ConfigParser(interpolation=None)
         config.read(config_path)
-        config.set('cache', 'manifest', bin_to_hex(bytes(32)))
-        with open(config_path, 'w') as fd:
+        config.set("cache", "manifest", bin_to_hex(bytes(32)))
+        with open(config_path, "w") as fd:
             config.write(fd)
 
-        out = self.cmd(f'--repo={self.repository_location}', 'rinfo')
-        assert 'Cache integrity data not available: old Borg version modified the cache.' in out
+        out = self.cmd(f"--repo={self.repository_location}", "rinfo")
+        assert "Cache integrity data not available: old Borg version modified the cache." in out
 
 
 class DiffArchiverTestCase(ArchiverTestCaseBase):
     def test_basic_functionality(self):
         # Setup files for the first snapshot
-        self.create_regular_file('empty', size=0)
-        self.create_regular_file('file_unchanged', size=128)
-        self.create_regular_file('file_removed', size=256)
-        self.create_regular_file('file_removed2', size=512)
-        self.create_regular_file('file_replaced', size=1024)
-        os.mkdir('input/dir_replaced_with_file')
-        os.chmod('input/dir_replaced_with_file', stat.S_IFDIR | 0o755)
-        os.mkdir('input/dir_removed')
+        self.create_regular_file("empty", size=0)
+        self.create_regular_file("file_unchanged", size=128)
+        self.create_regular_file("file_removed", size=256)
+        self.create_regular_file("file_removed2", size=512)
+        self.create_regular_file("file_replaced", size=1024)
+        os.mkdir("input/dir_replaced_with_file")
+        os.chmod("input/dir_replaced_with_file", stat.S_IFDIR | 0o755)
+        os.mkdir("input/dir_removed")
         if are_symlinks_supported():
-            os.mkdir('input/dir_replaced_with_link')
-            os.symlink('input/dir_replaced_with_file', 'input/link_changed')
-            os.symlink('input/file_unchanged', 'input/link_removed')
-            os.symlink('input/file_removed2', 'input/link_target_removed')
-            os.symlink('input/empty', 'input/link_target_contents_changed')
-            os.symlink('input/empty', 'input/link_replaced_by_file')
+            os.mkdir("input/dir_replaced_with_link")
+            os.symlink("input/dir_replaced_with_file", "input/link_changed")
+            os.symlink("input/file_unchanged", "input/link_removed")
+            os.symlink("input/file_removed2", "input/link_target_removed")
+            os.symlink("input/empty", "input/link_target_contents_changed")
+            os.symlink("input/empty", "input/link_replaced_by_file")
         if are_hardlinks_supported():
-            os.link('input/file_replaced', 'input/hardlink_target_replaced')
-            os.link('input/empty', 'input/hardlink_contents_changed')
-            os.link('input/file_removed', 'input/hardlink_removed')
-            os.link('input/file_removed2', 'input/hardlink_target_removed')
+            os.link("input/file_replaced", "input/hardlink_target_replaced")
+            os.link("input/empty", "input/hardlink_contents_changed")
+            os.link("input/file_removed", "input/hardlink_removed")
+            os.link("input/file_removed2", "input/hardlink_target_removed")
 
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
+        self.cmd(f"--repo={self.repository_location}", "rcreate", RK_ENCRYPTION)
 
         # Create the first snapshot
-        self.cmd(f'--repo={self.repository_location}', 'create', 'test0', 'input')
+        self.cmd(f"--repo={self.repository_location}", "create", "test0", "input")
 
         # Setup files for the second snapshot
-        self.create_regular_file('file_added', size=2048)
-        self.create_regular_file('file_empty_added', size=0)
-        os.unlink('input/file_replaced')
-        self.create_regular_file('file_replaced', contents=b'0' * 4096)
-        os.unlink('input/file_removed')
-        os.unlink('input/file_removed2')
-        os.rmdir('input/dir_replaced_with_file')
-        self.create_regular_file('dir_replaced_with_file', size=8192)
-        os.chmod('input/dir_replaced_with_file', stat.S_IFREG | 0o755)
-        os.mkdir('input/dir_added')
-        os.rmdir('input/dir_removed')
+        self.create_regular_file("file_added", size=2048)
+        self.create_regular_file("file_empty_added", size=0)
+        os.unlink("input/file_replaced")
+        self.create_regular_file("file_replaced", contents=b"0" * 4096)
+        os.unlink("input/file_removed")
+        os.unlink("input/file_removed2")
+        os.rmdir("input/dir_replaced_with_file")
+        self.create_regular_file("dir_replaced_with_file", size=8192)
+        os.chmod("input/dir_replaced_with_file", stat.S_IFREG | 0o755)
+        os.mkdir("input/dir_added")
+        os.rmdir("input/dir_removed")
         if are_symlinks_supported():
-            os.rmdir('input/dir_replaced_with_link')
-            os.symlink('input/dir_added', 'input/dir_replaced_with_link')
-            os.unlink('input/link_changed')
-            os.symlink('input/dir_added', 'input/link_changed')
-            os.symlink('input/dir_added', 'input/link_added')
-            os.unlink('input/link_replaced_by_file')
-            self.create_regular_file('link_replaced_by_file', size=16384)
-            os.unlink('input/link_removed')
+            os.rmdir("input/dir_replaced_with_link")
+            os.symlink("input/dir_added", "input/dir_replaced_with_link")
+            os.unlink("input/link_changed")
+            os.symlink("input/dir_added", "input/link_changed")
+            os.symlink("input/dir_added", "input/link_added")
+            os.unlink("input/link_replaced_by_file")
+            self.create_regular_file("link_replaced_by_file", size=16384)
+            os.unlink("input/link_removed")
         if are_hardlinks_supported():
-            os.unlink('input/hardlink_removed')
-            os.link('input/file_added', 'input/hardlink_added')
+            os.unlink("input/hardlink_removed")
+            os.link("input/file_added", "input/hardlink_added")
 
-        with open('input/empty', 'ab') as fd:
-            fd.write(b'appended_data')
+        with open("input/empty", "ab") as fd:
+            fd.write(b"appended_data")
 
         # Create the second snapshot
-        self.cmd(f'--repo={self.repository_location}', 'create', 'test1a', 'input')
-        self.cmd(f'--repo={self.repository_location}', 'create', 'test1b', 'input', '--chunker-params', '16,18,17,4095')
+        self.cmd(f"--repo={self.repository_location}", "create", "test1a", "input")
+        self.cmd(f"--repo={self.repository_location}", "create", "test1b", "input", "--chunker-params", "16,18,17,4095")
 
         def do_asserts(output, can_compare_ids):
             # File contents changed (deleted and replaced with a new file)
-            change = 'B' if can_compare_ids else '{:<19}'.format('modified')
-            assert 'file_replaced' in output  # added to debug #3494
-            assert f'{change} input/file_replaced' in output
+            change = "B" if can_compare_ids else "{:<19}".format("modified")
+            assert "file_replaced" in output  # added to debug #3494
+            assert f"{change} input/file_replaced" in output
 
             # File unchanged
-            assert 'input/file_unchanged' not in output
+            assert "input/file_unchanged" not in output
 
             # Directory replaced with a regular file
-            if 'BORG_TESTS_IGNORE_MODES' not in os.environ:
-                assert '[drwxr-xr-x -> -rwxr-xr-x] input/dir_replaced_with_file' in output
+            if "BORG_TESTS_IGNORE_MODES" not in os.environ:
+                assert "[drwxr-xr-x -> -rwxr-xr-x] input/dir_replaced_with_file" in output
 
             # Basic directory cases
-            assert 'added directory     input/dir_added' in output
-            assert 'removed directory   input/dir_removed' in output
+            assert "added directory     input/dir_added" in output
+            assert "removed directory   input/dir_removed" in output
 
             if are_symlinks_supported():
                 # Basic symlink cases
-                assert 'changed link        input/link_changed' in output
-                assert 'added link          input/link_added' in output
-                assert 'removed link        input/link_removed' in output
+                assert "changed link        input/link_changed" in output
+                assert "added link          input/link_added" in output
+                assert "removed link        input/link_removed" in output
 
                 # Symlink replacing or being replaced
-                assert '] input/dir_replaced_with_link' in output
-                assert '] input/link_replaced_by_file' in output
+                assert "] input/dir_replaced_with_link" in output
+                assert "] input/link_replaced_by_file" in output
 
                 # Symlink target removed. Should not affect the symlink at all.
-                assert 'input/link_target_removed' not in output
+                assert "input/link_target_removed" not in output
 
             # The inode has two links and the file contents changed. Borg
             # should notice the changes in both links. However, the symlink
             # pointing to the file is not changed.
-            change = '0 B' if can_compare_ids else '{:<19}'.format('modified')
-            assert f'{change} input/empty' in output
+            change = "0 B" if can_compare_ids else "{:<19}".format("modified")
+            assert f"{change} input/empty" in output
             if are_hardlinks_supported():
-                assert f'{change} input/hardlink_contents_changed' in output
+                assert f"{change} input/hardlink_contents_changed" in output
             if are_symlinks_supported():
-                assert 'input/link_target_contents_changed' not in output
+                assert "input/link_target_contents_changed" not in output
 
             # Added a new file and a hard link to it. Both links to the same
             # inode should appear as separate files.
-            assert 'added       2.05 kB input/file_added' in output
+            assert "added       2.05 kB input/file_added" in output
             if are_hardlinks_supported():
-                assert 'added       2.05 kB input/hardlink_added' in output
+                assert "added       2.05 kB input/hardlink_added" in output
 
             # check if a diff between non-existent and empty new file is found
-            assert 'added           0 B input/file_empty_added' in output
+            assert "added           0 B input/file_empty_added" in output
 
             # The inode has two links and both of them are deleted. They should
             # appear as two deleted files.
-            assert 'removed       256 B input/file_removed' in output
+            assert "removed       256 B input/file_removed" in output
             if are_hardlinks_supported():
-                assert 'removed       256 B input/hardlink_removed' in output
+                assert "removed       256 B input/hardlink_removed" in output
 
             # Another link (marked previously as the source in borg) to the
             # same inode was removed. This should not change this link at all.
             if are_hardlinks_supported():
-                assert 'input/hardlink_target_removed' not in output
+                assert "input/hardlink_target_removed" not in output
 
             # Another link (marked previously as the source in borg) to the
             # same inode was replaced with a new regular file. This should not
             # change this link at all.
             if are_hardlinks_supported():
-                assert 'input/hardlink_target_replaced' not in output
+                assert "input/hardlink_target_replaced" not in output
 
         def do_json_asserts(output, can_compare_ids):
             def get_changes(filename, data):
-                chgsets = [j['changes'] for j in data if j['path'] == filename]
+                chgsets = [j["changes"] for j in data if j["path"] == filename]
                 assert len(chgsets) < 2
                 # return a flattened list of changes for given filename
                 return [chg for chgset in chgsets for chg in chgset]
 
             # convert output to list of dicts
-            joutput = [json.loads(line) for line in output.split('\n') if line]
+            joutput = [json.loads(line) for line in output.split("\n") if line]
 
             # File contents changed (deleted and replaced with a new file)
-            expected = {'type': 'modified', 'added': 4096, 'removed': 1024} if can_compare_ids else {'type': 'modified'}
-            assert expected in get_changes('input/file_replaced', joutput)
+            expected = {"type": "modified", "added": 4096, "removed": 1024} if can_compare_ids else {"type": "modified"}
+            assert expected in get_changes("input/file_replaced", joutput)
 
             # File unchanged
-            assert not any(get_changes('input/file_unchanged', joutput))
+            assert not any(get_changes("input/file_unchanged", joutput))
 
             # Directory replaced with a regular file
-            if 'BORG_TESTS_IGNORE_MODES' not in os.environ:
-                assert {'type': 'mode', 'old_mode': 'drwxr-xr-x', 'new_mode': '-rwxr-xr-x'} in \
-                    get_changes('input/dir_replaced_with_file', joutput)
+            if "BORG_TESTS_IGNORE_MODES" not in os.environ:
+                assert {"type": "mode", "old_mode": "drwxr-xr-x", "new_mode": "-rwxr-xr-x"} in get_changes(
+                    "input/dir_replaced_with_file", joutput
+                )
 
             # Basic directory cases
-            assert {'type': 'added directory'} in get_changes('input/dir_added', joutput)
-            assert {'type': 'removed directory'} in get_changes('input/dir_removed', joutput)
+            assert {"type": "added directory"} in get_changes("input/dir_added", joutput)
+            assert {"type": "removed directory"} in get_changes("input/dir_removed", joutput)
 
             if are_symlinks_supported():
                 # Basic symlink cases
-                assert {'type': 'changed link'} in get_changes('input/link_changed', joutput)
-                assert {'type': 'added link'} in get_changes('input/link_added', joutput)
-                assert {'type': 'removed link'} in get_changes('input/link_removed', joutput)
+                assert {"type": "changed link"} in get_changes("input/link_changed", joutput)
+                assert {"type": "added link"} in get_changes("input/link_added", joutput)
+                assert {"type": "removed link"} in get_changes("input/link_removed", joutput)
 
                 # Symlink replacing or being replaced
-                assert any(chg['type'] == 'mode' and chg['new_mode'].startswith('l') for chg in
-                    get_changes('input/dir_replaced_with_link', joutput))
-                assert any(chg['type'] == 'mode' and chg['old_mode'].startswith('l') for chg in
-                    get_changes('input/link_replaced_by_file', joutput))
+                assert any(
+                    chg["type"] == "mode" and chg["new_mode"].startswith("l")
+                    for chg in get_changes("input/dir_replaced_with_link", joutput)
+                )
+                assert any(
+                    chg["type"] == "mode" and chg["old_mode"].startswith("l")
+                    for chg in get_changes("input/link_replaced_by_file", joutput)
+                )
 
                 # Symlink target removed. Should not affect the symlink at all.
-                assert not any(get_changes('input/link_target_removed', joutput))
+                assert not any(get_changes("input/link_target_removed", joutput))
 
             # The inode has two links and the file contents changed. Borg
             # should notice the changes in both links. However, the symlink
             # pointing to the file is not changed.
-            expected = {'type': 'modified', 'added': 13, 'removed': 0} if can_compare_ids else {'type': 'modified'}
-            assert expected in get_changes('input/empty', joutput)
+            expected = {"type": "modified", "added": 13, "removed": 0} if can_compare_ids else {"type": "modified"}
+            assert expected in get_changes("input/empty", joutput)
             if are_hardlinks_supported():
-                assert expected in get_changes('input/hardlink_contents_changed', joutput)
+                assert expected in get_changes("input/hardlink_contents_changed", joutput)
             if are_symlinks_supported():
-                assert not any(get_changes('input/link_target_contents_changed', joutput))
+                assert not any(get_changes("input/link_target_contents_changed", joutput))
 
             # Added a new file and a hard link to it. Both links to the same
             # inode should appear as separate files.
-            assert {'type': 'added', 'size': 2048} in get_changes('input/file_added', joutput)
+            assert {"type": "added", "size": 2048} in get_changes("input/file_added", joutput)
             if are_hardlinks_supported():
-                assert {'type': 'added', 'size': 2048} in get_changes('input/hardlink_added', joutput)
+                assert {"type": "added", "size": 2048} in get_changes("input/hardlink_added", joutput)
 
             # check if a diff between non-existent and empty new file is found
-            assert {'type': 'added', 'size': 0} in get_changes('input/file_empty_added', joutput)
+            assert {"type": "added", "size": 0} in get_changes("input/file_empty_added", joutput)
 
             # The inode has two links and both of them are deleted. They should
             # appear as two deleted files.
-            assert {'type': 'removed', 'size': 256} in get_changes('input/file_removed', joutput)
+            assert {"type": "removed", "size": 256} in get_changes("input/file_removed", joutput)
             if are_hardlinks_supported():
-                assert {'type': 'removed', 'size': 256} in get_changes('input/hardlink_removed', joutput)
+                assert {"type": "removed", "size": 256} in get_changes("input/hardlink_removed", joutput)
 
             # Another link (marked previously as the source in borg) to the
             # same inode was removed. This should not change this link at all.
             if are_hardlinks_supported():
-                assert not any(get_changes('input/hardlink_target_removed', joutput))
+                assert not any(get_changes("input/hardlink_target_removed", joutput))
 
             # Another link (marked previously as the source in borg) to the
             # same inode was replaced with a new regular file. This should not
             # change this link at all.
             if are_hardlinks_supported():
-                assert not any(get_changes('input/hardlink_target_replaced', joutput))
+                assert not any(get_changes("input/hardlink_target_replaced", joutput))
 
-        do_asserts(self.cmd(f'--repo={self.repository_location}', 'diff', 'test0', 'test1a'), True)
+        do_asserts(self.cmd(f"--repo={self.repository_location}", "diff", "test0", "test1a"), True)
         # We expect exit_code=1 due to the chunker params warning
-        do_asserts(self.cmd(f'--repo={self.repository_location}', 'diff', 'test0', 'test1b', exit_code=1), False)
-        do_json_asserts(self.cmd(f'--repo={self.repository_location}', 'diff', 'test0', 'test1a', '--json-lines'), True)
+        do_asserts(self.cmd(f"--repo={self.repository_location}", "diff", "test0", "test1b", exit_code=1), False)
+        do_json_asserts(self.cmd(f"--repo={self.repository_location}", "diff", "test0", "test1a", "--json-lines"), True)
 
     def test_sort_option(self):
-        self.cmd(f'--repo={self.repository_location}', 'rcreate', RK_ENCRYPTION)
+        self.cmd(f"--repo={self.repository_location}", "rcreate", RK_ENCRYPTION)
 
-        self.create_regular_file('a_file_removed', size=8)
-        self.create_regular_file('f_file_removed', size=16)
-        self.create_regular_file('c_file_changed', size=32)
-        self.create_regular_file('e_file_changed', size=64)
-        self.cmd(f'--repo={self.repository_location}', 'create', 'test0', 'input')
+        self.create_regular_file("a_file_removed", size=8)
+        self.create_regular_file("f_file_removed", size=16)
+        self.create_regular_file("c_file_changed", size=32)
+        self.create_regular_file("e_file_changed", size=64)
+        self.cmd(f"--repo={self.repository_location}", "create", "test0", "input")
 
-        os.unlink('input/a_file_removed')
-        os.unlink('input/f_file_removed')
-        os.unlink('input/c_file_changed')
-        os.unlink('input/e_file_changed')
-        self.create_regular_file('c_file_changed', size=512)
-        self.create_regular_file('e_file_changed', size=1024)
-        self.create_regular_file('b_file_added', size=128)
-        self.create_regular_file('d_file_added', size=256)
-        self.cmd(f'--repo={self.repository_location}', 'create', 'test1', 'input')
+        os.unlink("input/a_file_removed")
+        os.unlink("input/f_file_removed")
+        os.unlink("input/c_file_changed")
+        os.unlink("input/e_file_changed")
+        self.create_regular_file("c_file_changed", size=512)
+        self.create_regular_file("e_file_changed", size=1024)
+        self.create_regular_file("b_file_added", size=128)
+        self.create_regular_file("d_file_added", size=256)
+        self.cmd(f"--repo={self.repository_location}", "create", "test1", "input")
 
-        output = self.cmd(f'--repo={self.repository_location}', 'diff', 'test0', 'test1',
-                          '--sort')
+        output = self.cmd(f"--repo={self.repository_location}", "diff", "test0", "test1", "--sort")
         expected = [
-            'a_file_removed',
-            'b_file_added',
-            'c_file_changed',
-            'd_file_added',
-            'e_file_changed',
-            'f_file_removed',
+            "a_file_removed",
+            "b_file_added",
+            "c_file_changed",
+            "d_file_added",
+            "e_file_changed",
+            "f_file_removed",
         ]
 
         assert all(x in line for x, line in zip(expected, output.splitlines()))
@@ -4181,38 +4508,46 @@ def test_get_args():
     # everything normal:
     # first param is argv as produced by ssh forced command,
     # second param is like from SSH_ORIGINAL_COMMAND env variable
-    args = archiver.get_args(['borg', 'serve', '--umask=0027', '--restrict-to-path=/p1', '--restrict-to-path=/p2', ],
-                             'borg serve --info')
+    args = archiver.get_args(
+        ["borg", "serve", "--umask=0027", "--restrict-to-path=/p1", "--restrict-to-path=/p2"], "borg serve --info"
+    )
     assert args.func == archiver.do_serve
-    assert args.restrict_to_paths == ['/p1', '/p2']
+    assert args.restrict_to_paths == ["/p1", "/p2"]
     assert args.umask == 0o027
-    assert args.log_level == 'info'
+    assert args.log_level == "info"
     # similar, but with --restrict-to-repository
-    args = archiver.get_args(['borg', 'serve', '--restrict-to-repository=/r1', '--restrict-to-repository=/r2', ],
-                             'borg serve --info --umask=0027')
-    assert args.restrict_to_repositories == ['/r1', '/r2']
+    args = archiver.get_args(
+        ["borg", "serve", "--restrict-to-repository=/r1", "--restrict-to-repository=/r2"],
+        "borg serve --info --umask=0027",
+    )
+    assert args.restrict_to_repositories == ["/r1", "/r2"]
     # trying to cheat - break out of path restriction
-    args = archiver.get_args(['borg', 'serve', '--restrict-to-path=/p1', '--restrict-to-path=/p2', ],
-                             'borg serve --restrict-to-path=/')
-    assert args.restrict_to_paths == ['/p1', '/p2']
+    args = archiver.get_args(
+        ["borg", "serve", "--restrict-to-path=/p1", "--restrict-to-path=/p2"], "borg serve --restrict-to-path=/"
+    )
+    assert args.restrict_to_paths == ["/p1", "/p2"]
     # trying to cheat - break out of repository restriction
-    args = archiver.get_args(['borg', 'serve', '--restrict-to-repository=/r1', '--restrict-to-repository=/r2', ],
-                             'borg serve --restrict-to-repository=/')
-    assert args.restrict_to_repositories == ['/r1', '/r2']
+    args = archiver.get_args(
+        ["borg", "serve", "--restrict-to-repository=/r1", "--restrict-to-repository=/r2"],
+        "borg serve --restrict-to-repository=/",
+    )
+    assert args.restrict_to_repositories == ["/r1", "/r2"]
     # trying to cheat - break below repository restriction
-    args = archiver.get_args(['borg', 'serve', '--restrict-to-repository=/r1', '--restrict-to-repository=/r2', ],
-                             'borg serve --restrict-to-repository=/r1/below')
-    assert args.restrict_to_repositories == ['/r1', '/r2']
+    args = archiver.get_args(
+        ["borg", "serve", "--restrict-to-repository=/r1", "--restrict-to-repository=/r2"],
+        "borg serve --restrict-to-repository=/r1/below",
+    )
+    assert args.restrict_to_repositories == ["/r1", "/r2"]
     # trying to cheat - try to execute different subcommand
-    args = archiver.get_args(['borg', 'serve', '--restrict-to-path=/p1', '--restrict-to-path=/p2', ],
-                             f'borg --repo=/ rcreate {RK_ENCRYPTION}')
+    args = archiver.get_args(
+        ["borg", "serve", "--restrict-to-path=/p1", "--restrict-to-path=/p2"], f"borg --repo=/ rcreate {RK_ENCRYPTION}"
+    )
     assert args.func == archiver.do_serve
 
     # Check that environment variables in the forced command don't cause issues. If the command
     # were not forced, environment variables would be interpreted by the shell, but this does not
     # happen for forced commands - we get the verbatim command line and need to deal with env vars.
-    args = archiver.get_args(['borg', 'serve', ],
-                             'BORG_FOO=bar borg serve --info')
+    args = archiver.get_args(["borg", "serve"], "BORG_FOO=bar borg serve --info")
     assert args.func == archiver.do_serve
 
 
@@ -4224,98 +4559,91 @@ def test_chunk_content_equal():
         compare2 = chunks_contents_equal(iter(chunks_b), iter(chunks_a))
         assert compare1 == compare2
         return compare1
-    assert ccc([
-        b'1234', b'567A', b'bC'
-    ], [
-        b'1', b'23', b'4567A', b'b', b'C'
-    ])
+
+    assert ccc([b"1234", b"567A", b"bC"], [b"1", b"23", b"4567A", b"b", b"C"])
     # one iterator exhausted before the other
-    assert not ccc([
-        b'12345',
-    ], [
-        b'1234', b'56'
-    ])
+    assert not ccc([b"12345"], [b"1234", b"56"])
     # content mismatch
-    assert not ccc([
-        b'1234', b'65'
-    ], [
-        b'1234', b'56'
-    ])
+    assert not ccc([b"1234", b"65"], [b"1234", b"56"])
     # first is the prefix of second
-    assert not ccc([
-        b'1234', b'56'
-    ], [
-        b'1234', b'565'
-    ])
+    assert not ccc([b"1234", b"56"], [b"1234", b"565"])
 
 
 class TestBuildFilter:
-
     def test_basic(self):
         matcher = PatternMatcher()
-        matcher.add([parse_pattern('included')], IECommand.Include)
+        matcher.add([parse_pattern("included")], IECommand.Include)
         filter = Archiver.build_filter(matcher, 0)
-        assert filter(Item(path='included'))
-        assert filter(Item(path='included/file'))
-        assert not filter(Item(path='something else'))
+        assert filter(Item(path="included"))
+        assert filter(Item(path="included/file"))
+        assert not filter(Item(path="something else"))
 
     def test_empty(self):
         matcher = PatternMatcher(fallback=True)
         filter = Archiver.build_filter(matcher, 0)
-        assert filter(Item(path='anything'))
+        assert filter(Item(path="anything"))
 
     def test_strip_components(self):
         matcher = PatternMatcher(fallback=True)
         filter = Archiver.build_filter(matcher, strip_components=1)
-        assert not filter(Item(path='shallow'))
-        assert not filter(Item(path='shallow/'))  # can this even happen? paths are normalized...
-        assert filter(Item(path='deep enough/file'))
-        assert filter(Item(path='something/dir/file'))
+        assert not filter(Item(path="shallow"))
+        assert not filter(Item(path="shallow/"))  # can this even happen? paths are normalized...
+        assert filter(Item(path="deep enough/file"))
+        assert filter(Item(path="something/dir/file"))
 
 
 class TestCommonOptions:
     @staticmethod
     def define_common_options(add_common_option):
-        add_common_option('-h', '--help', action='help', help='show this help message and exit')
-        add_common_option('--critical', dest='log_level', help='foo',
-                          action='store_const', const='critical', default='warning')
-        add_common_option('--error', dest='log_level', help='foo',
-                          action='store_const', const='error', default='warning')
-        add_common_option('--append', dest='append', help='foo',
-                          action='append', metavar='TOPIC', default=[])
-        add_common_option('-p', '--progress', dest='progress', action='store_true', help='foo')
-        add_common_option('--lock-wait', dest='lock_wait', type=int, metavar='N', default=1,
-                          help='(default: %(default)d).')
+        add_common_option("-h", "--help", action="help", help="show this help message and exit")
+        add_common_option(
+            "--critical", dest="log_level", help="foo", action="store_const", const="critical", default="warning"
+        )
+        add_common_option(
+            "--error", dest="log_level", help="foo", action="store_const", const="error", default="warning"
+        )
+        add_common_option("--append", dest="append", help="foo", action="append", metavar="TOPIC", default=[])
+        add_common_option("-p", "--progress", dest="progress", action="store_true", help="foo")
+        add_common_option(
+            "--lock-wait", dest="lock_wait", type=int, metavar="N", default=1, help="(default: %(default)d)."
+        )
 
     @pytest.fixture
     def basic_parser(self):
-        parser = argparse.ArgumentParser(prog='test', description='test parser', add_help=False)
-        parser.common_options = Archiver.CommonOptions(self.define_common_options,
-                                                       suffix_precedence=('_level0', '_level1'))
+        parser = argparse.ArgumentParser(prog="test", description="test parser", add_help=False)
+        parser.common_options = Archiver.CommonOptions(
+            self.define_common_options, suffix_precedence=("_level0", "_level1")
+        )
         return parser
 
     @pytest.fixture
     def subparsers(self, basic_parser):
-        return basic_parser.add_subparsers(title='required arguments', metavar='<command>')
+        return basic_parser.add_subparsers(title="required arguments", metavar="<command>")
 
     @pytest.fixture
     def parser(self, basic_parser):
-        basic_parser.common_options.add_common_group(basic_parser, '_level0', provide_defaults=True)
+        basic_parser.common_options.add_common_group(basic_parser, "_level0", provide_defaults=True)
         return basic_parser
 
     @pytest.fixture
     def common_parser(self, parser):
-        common_parser = argparse.ArgumentParser(add_help=False, prog='test')
-        parser.common_options.add_common_group(common_parser, '_level1')
+        common_parser = argparse.ArgumentParser(add_help=False, prog="test")
+        parser.common_options.add_common_group(common_parser, "_level1")
         return common_parser
 
     @pytest.fixture
     def parse_vars_from_line(self, parser, subparsers, common_parser):
-        subparser = subparsers.add_parser('subcommand', parents=[common_parser], add_help=False,
-                                          description='foo', epilog='bar', help='baz',
-                                          formatter_class=argparse.RawDescriptionHelpFormatter)
+        subparser = subparsers.add_parser(
+            "subcommand",
+            parents=[common_parser],
+            add_help=False,
+            description="foo",
+            epilog="bar",
+            help="baz",
+            formatter_class=argparse.RawDescriptionHelpFormatter,
+        )
         subparser.set_defaults(func=1234)
-        subparser.add_argument('--append-only', dest='append_only', action='store_true')
+        subparser.add_argument("--append-only", dest="append_only", action="store_true")
 
         def parse_vars_from_line(*line):
             print(line)
@@ -4326,54 +4654,51 @@ class TestCommonOptions:
         return parse_vars_from_line
 
     def test_simple(self, parse_vars_from_line):
-        assert parse_vars_from_line('--error') == {
-            'append': [],
-            'lock_wait': 1,
-            'log_level': 'error',
-            'progress': False
+        assert parse_vars_from_line("--error") == {
+            "append": [],
+            "lock_wait": 1,
+            "log_level": "error",
+            "progress": False,
         }
 
-        assert parse_vars_from_line('--error', 'subcommand', '--critical') == {
-            'append': [],
-            'lock_wait': 1,
-            'log_level': 'critical',
-            'progress': False,
-            'append_only': False,
-            'func': 1234,
+        assert parse_vars_from_line("--error", "subcommand", "--critical") == {
+            "append": [],
+            "lock_wait": 1,
+            "log_level": "critical",
+            "progress": False,
+            "append_only": False,
+            "func": 1234,
         }
 
         with pytest.raises(SystemExit):
-            parse_vars_from_line('--append-only', 'subcommand')
+            parse_vars_from_line("--append-only", "subcommand")
 
-        assert parse_vars_from_line('--append=foo', '--append', 'bar', 'subcommand', '--append', 'baz') == {
-            'append': ['foo', 'bar', 'baz'],
-            'lock_wait': 1,
-            'log_level': 'warning',
-            'progress': False,
-            'append_only': False,
-            'func': 1234,
+        assert parse_vars_from_line("--append=foo", "--append", "bar", "subcommand", "--append", "baz") == {
+            "append": ["foo", "bar", "baz"],
+            "lock_wait": 1,
+            "log_level": "warning",
+            "progress": False,
+            "append_only": False,
+            "func": 1234,
         }
 
-    @pytest.mark.parametrize('position', ('before', 'after', 'both'))
-    @pytest.mark.parametrize('flag,args_key,args_value', (
-        ('-p', 'progress', True),
-        ('--lock-wait=3', 'lock_wait', 3),
-    ))
+    @pytest.mark.parametrize("position", ("before", "after", "both"))
+    @pytest.mark.parametrize("flag,args_key,args_value", (("-p", "progress", True), ("--lock-wait=3", "lock_wait", 3)))
     def test_flag_position_independence(self, parse_vars_from_line, position, flag, args_key, args_value):
         line = []
-        if position in ('before', 'both'):
+        if position in ("before", "both"):
             line.append(flag)
-        line.append('subcommand')
-        if position in ('after', 'both'):
+        line.append("subcommand")
+        if position in ("after", "both"):
             line.append(flag)
 
         result = {
-            'append': [],
-            'lock_wait': 1,
-            'log_level': 'warning',
-            'progress': False,
-            'append_only': False,
-            'func': 1234,
+            "append": [],
+            "lock_wait": 1,
+            "log_level": "warning",
+            "progress": False,
+            "append_only": False,
+            "func": 1234,
         }
         result[args_key] = args_value
 
@@ -4381,23 +4706,23 @@ class TestCommonOptions:
 
 
 def test_parse_storage_quota():
-    assert parse_storage_quota('50M') == 50 * 1000**2
+    assert parse_storage_quota("50M") == 50 * 1000**2
     with pytest.raises(argparse.ArgumentTypeError):
-        parse_storage_quota('5M')
+        parse_storage_quota("5M")
 
 
 def get_all_parsers():
     """
     Return dict mapping command to parser.
     """
-    parser = Archiver(prog='borg').build_parser()
-    borgfs_parser = Archiver(prog='borgfs').build_parser()
+    parser = Archiver(prog="borg").build_parser()
+    borgfs_parser = Archiver(prog="borgfs").build_parser()
     parsers = {}
 
     def discover_level(prefix, parser, Archiver, extra_choices=None):
         choices = {}
         for action in parser._actions:
-            if action.choices is not None and 'SubParsersAction' in str(action.__class__):
+            if action.choices is not None and "SubParsersAction" in str(action.__class__):
                 for cmd, parser in action.choices.items():
                     choices[prefix + cmd] = parser
         if extra_choices is not None:
@@ -4409,16 +4734,16 @@ def get_all_parsers():
             discover_level(command + " ", parser, Archiver)
             parsers[command] = parser
 
-    discover_level("", parser, Archiver, {'borgfs': borgfs_parser})
+    discover_level("", parser, Archiver, {"borgfs": borgfs_parser})
     return parsers
 
 
-@pytest.mark.parametrize('command, parser', list(get_all_parsers().items()))
+@pytest.mark.parametrize("command, parser", list(get_all_parsers().items()))
 def test_help_formatting(command, parser):
     if isinstance(parser.epilog, RstToTextLazy):
         assert parser.epilog.rst
 
 
-@pytest.mark.parametrize('topic, helptext', list(Archiver.helptext.items()))
+@pytest.mark.parametrize("topic, helptext", list(Archiver.helptext.items()))
 def test_help_formatting_helptexts(topic, helptext):
     assert str(rst_to_terminal(helptext))
diff --git a/src/borg/testsuite/benchmark.py b/src/borg/testsuite/benchmark.py
index cc21f19f6..563397ad5 100644
--- a/src/borg/testsuite/benchmark.py
+++ b/src/borg/testsuite/benchmark.py
@@ -16,35 +16,38 @@ from ..constants import zeros
 
 @pytest.fixture
 def repo_url(request, tmpdir, monkeypatch):
-    monkeypatch.setenv('BORG_PASSPHRASE', '123456')
-    monkeypatch.setenv('BORG_CHECK_I_KNOW_WHAT_I_AM_DOING', 'YES')
-    monkeypatch.setenv('BORG_DELETE_I_KNOW_WHAT_I_AM_DOING', 'YES')
-    monkeypatch.setenv('BORG_UNKNOWN_UNENCRYPTED_REPO_ACCESS_IS_OK', 'yes')
-    monkeypatch.setenv('BORG_KEYS_DIR', str(tmpdir.join('keys')))
-    monkeypatch.setenv('BORG_CACHE_DIR', str(tmpdir.join('cache')))
-    yield str(tmpdir.join('repository'))
+    monkeypatch.setenv("BORG_PASSPHRASE", "123456")
+    monkeypatch.setenv("BORG_CHECK_I_KNOW_WHAT_I_AM_DOING", "YES")
+    monkeypatch.setenv("BORG_DELETE_I_KNOW_WHAT_I_AM_DOING", "YES")
+    monkeypatch.setenv("BORG_UNKNOWN_UNENCRYPTED_REPO_ACCESS_IS_OK", "yes")
+    monkeypatch.setenv("BORG_KEYS_DIR", str(tmpdir.join("keys")))
+    monkeypatch.setenv("BORG_CACHE_DIR", str(tmpdir.join("cache")))
+    yield str(tmpdir.join("repository"))
     tmpdir.remove(rec=1)
 
 
 @pytest.fixture(params=["none", "repokey-aes-ocb"])
 def repo(request, cmd, repo_url):
-    cmd(f'--repo={repo_url}', 'rcreate', '--encryption', request.param)
+    cmd(f"--repo={repo_url}", "rcreate", "--encryption", request.param)
     return repo_url
 
 
-@pytest.fixture(scope='session', params=["zeros", "random"])
+@pytest.fixture(scope="session", params=["zeros", "random"])
 def testdata(request, tmpdir_factory):
-    count, size = 10, 1000*1000
+    count, size = 10, 1000 * 1000
     assert size <= len(zeros)
-    p = tmpdir_factory.mktemp('data')
+    p = tmpdir_factory.mktemp("data")
     data_type = request.param
-    if data_type == 'zeros':
+    if data_type == "zeros":
         # do not use a binary zero (\0) to avoid sparse detection
         def data(size):
             return memoryview(zeros)[:size]
-    elif data_type == 'random':
+
+    elif data_type == "random":
+
         def data(size):
             return os.urandom(size)
+
     else:
         raise ValueError("data_type must be 'random' or 'zeros'.")
     for i in range(count):
@@ -54,56 +57,54 @@ def testdata(request, tmpdir_factory):
     p.remove(rec=1)
 
 
-@pytest.fixture(params=['none', 'lz4'])
+@pytest.fixture(params=["none", "lz4"])
 def repo_archive(request, cmd, repo, testdata):
-    archive = 'test'
-    cmd(f'--repo={repo}', 'create', '--compression', request.param, archive, testdata)
+    archive = "test"
+    cmd(f"--repo={repo}", "create", "--compression", request.param, archive, testdata)
     return repo, archive
 
 
 def test_create_none(benchmark, cmd, repo, testdata):
-    result, out = benchmark.pedantic(cmd, (f'--repo={repo}', 'create', '--compression', 'none',
-                                           'test', testdata))
+    result, out = benchmark.pedantic(cmd, (f"--repo={repo}", "create", "--compression", "none", "test", testdata))
     assert result == 0
 
 
 def test_create_lz4(benchmark, cmd, repo, testdata):
-    result, out = benchmark.pedantic(cmd, (f'--repo={repo}', 'create', '--compression', 'lz4',
-                                           'test', testdata))
+    result, out = benchmark.pedantic(cmd, (f"--repo={repo}", "create", "--compression", "lz4", "test", testdata))
     assert result == 0
 
 
 def test_extract(benchmark, cmd, repo_archive, tmpdir):
     repo, archive = repo_archive
     with changedir(str(tmpdir)):
-        result, out = benchmark.pedantic(cmd, (f'--repo={repo}', 'extract', archive))
+        result, out = benchmark.pedantic(cmd, (f"--repo={repo}", "extract", archive))
     assert result == 0
 
 
 def test_delete(benchmark, cmd, repo_archive):
     repo, archive = repo_archive
-    result, out = benchmark.pedantic(cmd, (f'--repo={repo}', 'delete', '-a', archive))
+    result, out = benchmark.pedantic(cmd, (f"--repo={repo}", "delete", "-a", archive))
     assert result == 0
 
 
 def test_list(benchmark, cmd, repo_archive):
     repo, archive = repo_archive
-    result, out = benchmark(cmd, f'--repo={repo}', 'list', archive)
+    result, out = benchmark(cmd, f"--repo={repo}", "list", archive)
     assert result == 0
 
 
 def test_info(benchmark, cmd, repo_archive):
     repo, archive = repo_archive
-    result, out = benchmark(cmd, f'--repo={repo}', 'info', '-a', archive)
+    result, out = benchmark(cmd, f"--repo={repo}", "info", "-a", archive)
     assert result == 0
 
 
 def test_check(benchmark, cmd, repo_archive):
     repo, archive = repo_archive
-    result, out = benchmark(cmd, f'--repo={repo}', 'check')
+    result, out = benchmark(cmd, f"--repo={repo}", "check")
     assert result == 0
 
 
 def test_help(benchmark, cmd):
-    result, out = benchmark(cmd, 'help')
+    result, out = benchmark(cmd, "help")
     assert result == 0
diff --git a/src/borg/testsuite/cache.py b/src/borg/testsuite/cache.py
index f642a588e..a1c8be16a 100644
--- a/src/borg/testsuite/cache.py
+++ b/src/borg/testsuite/cache.py
@@ -26,75 +26,29 @@ class TestCacheSynchronizer:
         return CacheSynchronizer(index)
 
     def test_no_chunks(self, index, sync):
-        data = packb({
-            'foo': 'bar',
-            'baz': 1234,
-            'bar': 5678,
-            'user': 'chunks',
-            'chunks': []
-        })
+        data = packb({"foo": "bar", "baz": 1234, "bar": 5678, "user": "chunks", "chunks": []})
         sync.feed(data)
         assert not len(index)
 
     def test_simple(self, index, sync):
-        data = packb({
-            'foo': 'bar',
-            'baz': 1234,
-            'bar': 5678,
-            'user': 'chunks',
-            'chunks': [
-                (H(1), 1),
-                (H(2), 2),
-            ]
-        })
+        data = packb({"foo": "bar", "baz": 1234, "bar": 5678, "user": "chunks", "chunks": [(H(1), 1), (H(2), 2)]})
         sync.feed(data)
         assert len(index) == 2
         assert index[H(1)] == (1, 1)
         assert index[H(2)] == (1, 2)
 
     def test_multiple(self, index, sync):
-        data = packb({
-            'foo': 'bar',
-            'baz': 1234,
-            'bar': 5678,
-            'user': 'chunks',
-            'chunks': [
-                (H(1), 1),
-                (H(2), 2),
-            ]
-        })
-        data += packb({
-            'xattrs': {
-                'security.foo': 'bar',
-                'chunks': '123456',
-            },
-            'stuff': [
-                (1, 2, 3),
-            ]
-        })
-        data += packb({
-            'xattrs': {
-                'security.foo': 'bar',
-                'chunks': '123456',
-            },
-            'chunks': [
-                (H(1), 1),
-                (H(2), 2),
-            ],
-            'stuff': [
-                (1, 2, 3),
-            ]
-        })
-        data += packb({
-            'chunks': [
-                (H(3), 1),
-            ],
-        })
-        data += packb({
-            'chunks': [
-                (H(1), 1),
-            ],
-        })
+        data = packb({"foo": "bar", "baz": 1234, "bar": 5678, "user": "chunks", "chunks": [(H(1), 1), (H(2), 2)]})
+        data += packb({"xattrs": {"security.foo": "bar", "chunks": "123456"}, "stuff": [(1, 2, 3)]})
+        data += packb(
+            {
+                "xattrs": {"security.foo": "bar", "chunks": "123456"},
+                "chunks": [(H(1), 1), (H(2), 2)],
+                "stuff": [(1, 2, 3)],
+            }
+        )
+        data += packb({"chunks": [(H(3), 1)]})
+        data += packb({"chunks": [(H(1), 1)]})
 
         part1 = data[:70]
         part2 = data[70:120]
@@ -107,62 +61,68 @@ class TestCacheSynchronizer:
         assert index[H(2)] == (2, 2)
         assert index[H(3)] == (1, 1)
 
-    @pytest.mark.parametrize('elem,error', (
-        ({1: 2}, 'Unexpected object: map'),
-        (bytes(213), [
-            'Unexpected bytes in chunks structure',  # structure 2/3
-            'Incorrect key length']),                # structure 3/3
-        (1, 'Unexpected object: integer'),
-        (1.0, 'Unexpected object: double'),
-        (True, 'Unexpected object: true'),
-        (False, 'Unexpected object: false'),
-        (None, 'Unexpected object: nil'),
-    ))
-    @pytest.mark.parametrize('structure', (
-        lambda elem: {'chunks': elem},
-        lambda elem: {'chunks': [elem]},
-        lambda elem: {'chunks': [(elem, 1)]},
-    ))
+    @pytest.mark.parametrize(
+        "elem,error",
+        (
+            ({1: 2}, "Unexpected object: map"),
+            (
+                bytes(213),
+                ["Unexpected bytes in chunks structure", "Incorrect key length"],  # structure 2/3
+            ),  # structure 3/3
+            (1, "Unexpected object: integer"),
+            (1.0, "Unexpected object: double"),
+            (True, "Unexpected object: true"),
+            (False, "Unexpected object: false"),
+            (None, "Unexpected object: nil"),
+        ),
+    )
+    @pytest.mark.parametrize(
+        "structure",
+        (lambda elem: {"chunks": elem}, lambda elem: {"chunks": [elem]}, lambda elem: {"chunks": [(elem, 1)]}),
+    )
     def test_corrupted(self, sync, structure, elem, error):
         packed = packb(structure(elem))
         with pytest.raises(ValueError) as excinfo:
             sync.feed(packed)
         if isinstance(error, str):
             error = [error]
-        possible_errors = ['cache_sync_feed failed: ' + error for error in error]
+        possible_errors = ["cache_sync_feed failed: " + error for error in error]
         assert str(excinfo.value) in possible_errors
 
-    @pytest.mark.parametrize('data,error', (
-        # Incorrect tuple length
-        ({'chunks': [(bytes(32), 2, 3, 4)]}, 'Invalid chunk list entry length'),
-        ({'chunks': [(bytes(32), )]}, 'Invalid chunk list entry length'),
-        # Incorrect types
-        ({'chunks': [(1, 2)]}, 'Unexpected object: integer'),
-        ({'chunks': [(1, bytes(32))]}, 'Unexpected object: integer'),
-        ({'chunks': [(bytes(32), 1.0)]}, 'Unexpected object: double'),
-    ))
+    @pytest.mark.parametrize(
+        "data,error",
+        (
+            # Incorrect tuple length
+            ({"chunks": [(bytes(32), 2, 3, 4)]}, "Invalid chunk list entry length"),
+            ({"chunks": [(bytes(32),)]}, "Invalid chunk list entry length"),
+            # Incorrect types
+            ({"chunks": [(1, 2)]}, "Unexpected object: integer"),
+            ({"chunks": [(1, bytes(32))]}, "Unexpected object: integer"),
+            ({"chunks": [(bytes(32), 1.0)]}, "Unexpected object: double"),
+        ),
+    )
     def test_corrupted_ancillary(self, index, sync, data, error):
         packed = packb(data)
         with pytest.raises(ValueError) as excinfo:
             sync.feed(packed)
-        assert str(excinfo.value) == 'cache_sync_feed failed: ' + error
+        assert str(excinfo.value) == "cache_sync_feed failed: " + error
 
     def make_index_with_refcount(self, refcount):
         index_data = io.BytesIO()
-        index_data.write(b'BORG_IDX')
+        index_data.write(b"BORG_IDX")
         # num_entries
-        index_data.write((1).to_bytes(4, 'little'))
+        index_data.write((1).to_bytes(4, "little"))
         # num_buckets
-        index_data.write((1).to_bytes(4, 'little'))
+        index_data.write((1).to_bytes(4, "little"))
         # key_size
-        index_data.write((32).to_bytes(1, 'little'))
+        index_data.write((32).to_bytes(1, "little"))
         # value_size
-        index_data.write((3 * 4).to_bytes(1, 'little'))
+        index_data.write((3 * 4).to_bytes(1, "little"))
 
         index_data.write(H(0))
-        index_data.write(refcount.to_bytes(4, 'little'))
-        index_data.write((1234).to_bytes(4, 'little'))
-        index_data.write((5678).to_bytes(4, 'little'))
+        index_data.write(refcount.to_bytes(4, "little"))
+        index_data.write((1234).to_bytes(4, "little"))
+        index_data.write((5678).to_bytes(4, "little"))
 
         index_data.seek(0)
         index = ChunkIndex.read(index_data)
@@ -171,34 +131,22 @@ class TestCacheSynchronizer:
     def test_corrupted_refcount(self):
         index = self.make_index_with_refcount(ChunkIndex.MAX_VALUE + 1)
         sync = CacheSynchronizer(index)
-        data = packb({
-            'chunks': [
-                (H(0), 1),
-            ]
-        })
+        data = packb({"chunks": [(H(0), 1)]})
         with pytest.raises(ValueError) as excinfo:
             sync.feed(data)
-        assert str(excinfo.value) == 'cache_sync_feed failed: invalid reference count'
+        assert str(excinfo.value) == "cache_sync_feed failed: invalid reference count"
 
     def test_refcount_max_value(self):
         index = self.make_index_with_refcount(ChunkIndex.MAX_VALUE)
         sync = CacheSynchronizer(index)
-        data = packb({
-            'chunks': [
-                (H(0), 1),
-            ]
-        })
+        data = packb({"chunks": [(H(0), 1)]})
         sync.feed(data)
         assert index[H(0)] == (ChunkIndex.MAX_VALUE, 1234)
 
     def test_refcount_one_below_max_value(self):
         index = self.make_index_with_refcount(ChunkIndex.MAX_VALUE - 1)
         sync = CacheSynchronizer(index)
-        data = packb({
-            'chunks': [
-                (H(0), 1),
-            ]
-        })
+        data = packb({"chunks": [(H(0), 1)]})
         sync.feed(data)
         # Incremented to maximum
         assert index[H(0)] == (ChunkIndex.MAX_VALUE, 1234)
@@ -209,17 +157,17 @@ class TestCacheSynchronizer:
 class TestAdHocCache:
     @pytest.fixture
     def repository(self, tmpdir):
-        self.repository_location = os.path.join(str(tmpdir), 'repository')
+        self.repository_location = os.path.join(str(tmpdir), "repository")
         with Repository(self.repository_location, exclusive=True, create=True) as repository:
-            repository.put(H(1), b'1234')
-            repository.put(Manifest.MANIFEST_ID, b'5678')
+            repository.put(H(1), b"1234")
+            repository.put(Manifest.MANIFEST_ID, b"5678")
             yield repository
 
     @pytest.fixture
     def key(self, repository, monkeypatch):
-        monkeypatch.setenv('BORG_PASSPHRASE', 'test')
+        monkeypatch.setenv("BORG_PASSPHRASE", "test")
         key = AESOCBRepoKey.create(repository, TestKey.MockArgs())
-        key.compressor = CompressionSpec('none').compressor
+        key.compressor = CompressionSpec("none").compressor
         return key
 
     @pytest.fixture
@@ -237,18 +185,18 @@ class TestAdHocCache:
     def test_does_not_delete_existing_chunks(self, repository, cache):
         assert cache.seen_chunk(H(1)) == ChunkIndex.MAX_VALUE
         cache.chunk_decref(H(1), Statistics())
-        assert repository.get(H(1)) == b'1234'
+        assert repository.get(H(1)) == b"1234"
 
     def test_does_not_overwrite(self, cache):
         with pytest.raises(AssertionError):
-            cache.add_chunk(H(1), b'5678', Statistics(), overwrite=True)
+            cache.add_chunk(H(1), b"5678", Statistics(), overwrite=True)
 
     def test_seen_chunk_add_chunk_size(self, cache):
-        assert cache.add_chunk(H(1), b'5678', Statistics()) == (H(1), 4)
+        assert cache.add_chunk(H(1), b"5678", Statistics()) == (H(1), 4)
 
     def test_deletes_chunks_during_lifetime(self, cache, repository):
         """E.g. checkpoint archives"""
-        cache.add_chunk(H(5), b'1010', Statistics())
+        cache.add_chunk(H(5), b"1010", Statistics())
         assert cache.seen_chunk(H(5)) == 1
         cache.chunk_decref(H(5), Statistics())
         assert not cache.seen_chunk(H(5))
@@ -256,8 +204,8 @@ class TestAdHocCache:
             repository.get(H(5))
 
     def test_files_cache(self, cache):
-        assert cache.file_known_and_unchanged(b'foo', bytes(32), None) == (False, None)
-        assert cache.cache_mode == 'd'
+        assert cache.file_known_and_unchanged(b"foo", bytes(32), None) == (False, None)
+        assert cache.cache_mode == "d"
         assert cache.files is None
 
     def test_txn(self, cache):
@@ -267,13 +215,13 @@ class TestAdHocCache:
         assert cache.chunks
         cache.rollback()
         assert not cache._txn_active
-        assert not hasattr(cache, 'chunks')
+        assert not hasattr(cache, "chunks")
 
     def test_incref_after_add_chunk(self, cache):
-        assert cache.add_chunk(H(3), b'5678', Statistics()) == (H(3), 4)
+        assert cache.add_chunk(H(3), b"5678", Statistics()) == (H(3), 4)
         assert cache.chunk_incref(H(3), Statistics()) == (H(3), 4)
 
     def test_existing_incref_after_add_chunk(self, cache):
         """This case occurs with part files, see Archive.chunk_file."""
-        assert cache.add_chunk(H(1), b'5678', Statistics()) == (H(1), 4)
+        assert cache.add_chunk(H(1), b"5678", Statistics()) == (H(1), 4)
         assert cache.chunk_incref(H(1), Statistics()) == (H(1), 4)
diff --git a/src/borg/testsuite/checksums.py b/src/borg/testsuite/checksums.py
index 2567fda8a..9a4f63753 100644
--- a/src/borg/testsuite/checksums.py
+++ b/src/borg/testsuite/checksums.py
@@ -5,16 +5,24 @@ from ..helpers import bin_to_hex
 
 
 def test_xxh64():
-    assert bin_to_hex(checksums.xxh64(b'test', 123)) == '2b81b9401bef86cf'
-    assert bin_to_hex(checksums.xxh64(b'test')) == '4fdcca5ddb678139'
-    assert bin_to_hex(checksums.xxh64(unhexlify(
-        '6f663f01c118abdea553373d5eae44e7dac3b6829b46b9bbeff202b6c592c22d724'
-        'fb3d25a347cca6c5b8f20d567e4bb04b9cfa85d17f691590f9a9d32e8ccc9102e9d'
-        'cf8a7e6716280cd642ce48d03fdf114c9f57c20d9472bb0f81c147645e6fa3d331'))) == '35d5d2f545d9511a'
+    assert bin_to_hex(checksums.xxh64(b"test", 123)) == "2b81b9401bef86cf"
+    assert bin_to_hex(checksums.xxh64(b"test")) == "4fdcca5ddb678139"
+    assert (
+        bin_to_hex(
+            checksums.xxh64(
+                unhexlify(
+                    "6f663f01c118abdea553373d5eae44e7dac3b6829b46b9bbeff202b6c592c22d724"
+                    "fb3d25a347cca6c5b8f20d567e4bb04b9cfa85d17f691590f9a9d32e8ccc9102e9d"
+                    "cf8a7e6716280cd642ce48d03fdf114c9f57c20d9472bb0f81c147645e6fa3d331"
+                )
+            )
+        )
+        == "35d5d2f545d9511a"
+    )
 
 
 def test_streaming_xxh64():
     hasher = checksums.StreamingXXH64(123)
-    hasher.update(b'te')
-    hasher.update(b'st')
-    assert bin_to_hex(hasher.digest()) == hasher.hexdigest() == '2b81b9401bef86cf'
+    hasher.update(b"te")
+    hasher.update(b"st")
+    assert bin_to_hex(hasher.digest()) == hasher.hexdigest() == "2b81b9401bef86cf"
diff --git a/src/borg/testsuite/chunker.py b/src/borg/testsuite/chunker.py
index ce45b7c96..54aade3ea 100644
--- a/src/borg/testsuite/chunker.py
+++ b/src/borg/testsuite/chunker.py
@@ -12,113 +12,129 @@ def cf(chunks):
     """chunk filter"""
     # this is to simplify testing: either return the data piece (bytes) or the hole length (int).
     def _cf(chunk):
-        if chunk.meta['allocation'] == CH_DATA:
-            assert len(chunk.data) == chunk.meta['size']
+        if chunk.meta["allocation"] == CH_DATA:
+            assert len(chunk.data) == chunk.meta["size"]
             return bytes(chunk.data)  # make sure we have bytes, not memoryview
-        if chunk.meta['allocation'] in (CH_HOLE, CH_ALLOC):
+        if chunk.meta["allocation"] in (CH_HOLE, CH_ALLOC):
             assert chunk.data is None
-            return chunk.meta['size']
+            return chunk.meta["size"]
         assert False, "unexpected allocation value"
+
     return [_cf(chunk) for chunk in chunks]
 
 
 class ChunkerFixedTestCase(BaseTestCase):
-
     def test_chunkify_just_blocks(self):
-        data = b'foobar' * 1500
+        data = b"foobar" * 1500
         chunker = ChunkerFixed(4096)
         parts = cf(chunker.chunkify(BytesIO(data)))
         self.assert_equal(parts, [data[0:4096], data[4096:8192], data[8192:]])
 
     def test_chunkify_header_and_blocks(self):
-        data = b'foobar' * 1500
+        data = b"foobar" * 1500
         chunker = ChunkerFixed(4096, 123)
         parts = cf(chunker.chunkify(BytesIO(data)))
-        self.assert_equal(parts, [data[0:123], data[123:123+4096], data[123+4096:123+8192], data[123+8192:]])
+        self.assert_equal(
+            parts, [data[0:123], data[123 : 123 + 4096], data[123 + 4096 : 123 + 8192], data[123 + 8192 :]]
+        )
 
     def test_chunkify_just_blocks_fmap_complete(self):
-        data = b'foobar' * 1500
+        data = b"foobar" * 1500
         chunker = ChunkerFixed(4096)
-        fmap = [
-            (0, 4096, True),
-            (4096, 8192, True),
-            (8192, 99999999, True),
-        ]
+        fmap = [(0, 4096, True), (4096, 8192, True), (8192, 99999999, True)]
         parts = cf(chunker.chunkify(BytesIO(data), fmap=fmap))
         self.assert_equal(parts, [data[0:4096], data[4096:8192], data[8192:]])
 
     def test_chunkify_header_and_blocks_fmap_complete(self):
-        data = b'foobar' * 1500
+        data = b"foobar" * 1500
         chunker = ChunkerFixed(4096, 123)
-        fmap = [
-            (0, 123, True),
-            (123, 4096, True),
-            (123+4096, 4096, True),
-            (123+8192, 4096, True),
-        ]
+        fmap = [(0, 123, True), (123, 4096, True), (123 + 4096, 4096, True), (123 + 8192, 4096, True)]
         parts = cf(chunker.chunkify(BytesIO(data), fmap=fmap))
-        self.assert_equal(parts, [data[0:123], data[123:123+4096], data[123+4096:123+8192], data[123+8192:]])
+        self.assert_equal(
+            parts, [data[0:123], data[123 : 123 + 4096], data[123 + 4096 : 123 + 8192], data[123 + 8192 :]]
+        )
 
     def test_chunkify_header_and_blocks_fmap_zeros(self):
-        data = b'H' * 123 + b'_' * 4096 + b'X' * 4096 + b'_' * 4096
+        data = b"H" * 123 + b"_" * 4096 + b"X" * 4096 + b"_" * 4096
         chunker = ChunkerFixed(4096, 123)
-        fmap = [
-            (0, 123, True),
-            (123, 4096, False),
-            (123+4096, 4096, True),
-            (123+8192, 4096, False),
-        ]
+        fmap = [(0, 123, True), (123, 4096, False), (123 + 4096, 4096, True), (123 + 8192, 4096, False)]
         parts = cf(chunker.chunkify(BytesIO(data), fmap=fmap))
         # because we marked the '_' ranges as holes, we will get hole ranges instead!
-        self.assert_equal(parts, [data[0:123], 4096, data[123+4096:123+8192], 4096])
+        self.assert_equal(parts, [data[0:123], 4096, data[123 + 4096 : 123 + 8192], 4096])
 
     def test_chunkify_header_and_blocks_fmap_partial(self):
-        data = b'H' * 123 + b'_' * 4096 + b'X' * 4096 + b'_' * 4096
+        data = b"H" * 123 + b"_" * 4096 + b"X" * 4096 + b"_" * 4096
         chunker = ChunkerFixed(4096, 123)
         fmap = [
             (0, 123, True),
             # (123, 4096, False),
-            (123+4096, 4096, True),
+            (123 + 4096, 4096, True),
             # (123+8192, 4096, False),
         ]
         parts = cf(chunker.chunkify(BytesIO(data), fmap=fmap))
         # because we left out the '_' ranges from the fmap, we will not get them at all!
-        self.assert_equal(parts, [data[0:123], data[123+4096:123+8192]])
+        self.assert_equal(parts, [data[0:123], data[123 + 4096 : 123 + 8192]])
 
 
 class ChunkerTestCase(BaseTestCase):
-
     def test_chunkify(self):
-        data = b'0' * int(1.5 * (1 << CHUNK_MAX_EXP)) + b'Y'
+        data = b"0" * int(1.5 * (1 << CHUNK_MAX_EXP)) + b"Y"
         parts = cf(Chunker(0, 1, CHUNK_MAX_EXP, 2, 2).chunkify(BytesIO(data)))
         self.assert_equal(len(parts), 2)
-        self.assert_equal(b''.join(parts), data)
-        self.assert_equal(cf(Chunker(0, 1, CHUNK_MAX_EXP, 2, 2).chunkify(BytesIO(b''))), [])
-        self.assert_equal(cf(Chunker(0, 1, CHUNK_MAX_EXP, 2, 2).chunkify(BytesIO(b'foobarboobaz' * 3))), [b'fooba', b'rboobaz', b'fooba', b'rboobaz', b'fooba', b'rboobaz'])
-        self.assert_equal(cf(Chunker(1, 1, CHUNK_MAX_EXP, 2, 2).chunkify(BytesIO(b'foobarboobaz' * 3))), [b'fo', b'obarb', b'oob', b'azf', b'oobarb', b'oob', b'azf', b'oobarb', b'oobaz'])
-        self.assert_equal(cf(Chunker(2, 1, CHUNK_MAX_EXP, 2, 2).chunkify(BytesIO(b'foobarboobaz' * 3))), [b'foob', b'ar', b'boobazfoob', b'ar', b'boobazfoob', b'ar', b'boobaz'])
-        self.assert_equal(cf(Chunker(0, 2, CHUNK_MAX_EXP, 2, 3).chunkify(BytesIO(b'foobarboobaz' * 3))), [b'foobarboobaz' * 3])
-        self.assert_equal(cf(Chunker(1, 2, CHUNK_MAX_EXP, 2, 3).chunkify(BytesIO(b'foobarboobaz' * 3))), [b'foobar', b'boobazfo', b'obar', b'boobazfo', b'obar', b'boobaz'])
-        self.assert_equal(cf(Chunker(2, 2, CHUNK_MAX_EXP, 2, 3).chunkify(BytesIO(b'foobarboobaz' * 3))), [b'foob', b'arboobaz', b'foob', b'arboobaz', b'foob', b'arboobaz'])
-        self.assert_equal(cf(Chunker(0, 3, CHUNK_MAX_EXP, 2, 3).chunkify(BytesIO(b'foobarboobaz' * 3))), [b'foobarboobaz' * 3])
-        self.assert_equal(cf(Chunker(1, 3, CHUNK_MAX_EXP, 2, 3).chunkify(BytesIO(b'foobarboobaz' * 3))), [b'foobarbo', b'obazfoobar', b'boobazfo', b'obarboobaz'])
-        self.assert_equal(cf(Chunker(2, 3, CHUNK_MAX_EXP, 2, 3).chunkify(BytesIO(b'foobarboobaz' * 3))), [b'foobarboobaz', b'foobarboobaz', b'foobarboobaz'])
+        self.assert_equal(b"".join(parts), data)
+        self.assert_equal(cf(Chunker(0, 1, CHUNK_MAX_EXP, 2, 2).chunkify(BytesIO(b""))), [])
+        self.assert_equal(
+            cf(Chunker(0, 1, CHUNK_MAX_EXP, 2, 2).chunkify(BytesIO(b"foobarboobaz" * 3))),
+            [b"fooba", b"rboobaz", b"fooba", b"rboobaz", b"fooba", b"rboobaz"],
+        )
+        self.assert_equal(
+            cf(Chunker(1, 1, CHUNK_MAX_EXP, 2, 2).chunkify(BytesIO(b"foobarboobaz" * 3))),
+            [b"fo", b"obarb", b"oob", b"azf", b"oobarb", b"oob", b"azf", b"oobarb", b"oobaz"],
+        )
+        self.assert_equal(
+            cf(Chunker(2, 1, CHUNK_MAX_EXP, 2, 2).chunkify(BytesIO(b"foobarboobaz" * 3))),
+            [b"foob", b"ar", b"boobazfoob", b"ar", b"boobazfoob", b"ar", b"boobaz"],
+        )
+        self.assert_equal(
+            cf(Chunker(0, 2, CHUNK_MAX_EXP, 2, 3).chunkify(BytesIO(b"foobarboobaz" * 3))), [b"foobarboobaz" * 3]
+        )
+        self.assert_equal(
+            cf(Chunker(1, 2, CHUNK_MAX_EXP, 2, 3).chunkify(BytesIO(b"foobarboobaz" * 3))),
+            [b"foobar", b"boobazfo", b"obar", b"boobazfo", b"obar", b"boobaz"],
+        )
+        self.assert_equal(
+            cf(Chunker(2, 2, CHUNK_MAX_EXP, 2, 3).chunkify(BytesIO(b"foobarboobaz" * 3))),
+            [b"foob", b"arboobaz", b"foob", b"arboobaz", b"foob", b"arboobaz"],
+        )
+        self.assert_equal(
+            cf(Chunker(0, 3, CHUNK_MAX_EXP, 2, 3).chunkify(BytesIO(b"foobarboobaz" * 3))), [b"foobarboobaz" * 3]
+        )
+        self.assert_equal(
+            cf(Chunker(1, 3, CHUNK_MAX_EXP, 2, 3).chunkify(BytesIO(b"foobarboobaz" * 3))),
+            [b"foobarbo", b"obazfoobar", b"boobazfo", b"obarboobaz"],
+        )
+        self.assert_equal(
+            cf(Chunker(2, 3, CHUNK_MAX_EXP, 2, 3).chunkify(BytesIO(b"foobarboobaz" * 3))),
+            [b"foobarboobaz", b"foobarboobaz", b"foobarboobaz"],
+        )
 
     def test_buzhash(self):
-        self.assert_equal(buzhash(b'abcdefghijklmnop', 0), 3795437769)
-        self.assert_equal(buzhash(b'abcdefghijklmnop', 1), 3795400502)
-        self.assert_equal(buzhash(b'abcdefghijklmnop', 1), buzhash_update(buzhash(b'Xabcdefghijklmno', 1), ord('X'), ord('p'), 16, 1))
+        self.assert_equal(buzhash(b"abcdefghijklmnop", 0), 3795437769)
+        self.assert_equal(buzhash(b"abcdefghijklmnop", 1), 3795400502)
+        self.assert_equal(
+            buzhash(b"abcdefghijklmnop", 1), buzhash_update(buzhash(b"Xabcdefghijklmno", 1), ord("X"), ord("p"), 16, 1)
+        )
         # Test with more than 31 bytes to make sure our barrel_shift macro works correctly
-        self.assert_equal(buzhash(b'abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz', 0), 566521248)
+        self.assert_equal(buzhash(b"abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz", 0), 566521248)
 
     def test_small_reads(self):
         class SmallReadFile:
-            input = b'a' * (20 + 1)
+            input = b"a" * (20 + 1)
 
             def read(self, nbytes):
                 self.input = self.input[:-1]
                 return self.input[:1]
 
         chunker = get_chunker(*CHUNKER_PARAMS, seed=0)
-        reconstructed = b''.join(cf(chunker.chunkify(SmallReadFile())))
-        assert reconstructed == b'a' * 20
+        reconstructed = b"".join(cf(chunker.chunkify(SmallReadFile())))
+        assert reconstructed == b"a" * 20
diff --git a/src/borg/testsuite/chunker_pytest.py b/src/borg/testsuite/chunker_pytest.py
index 59c7a4515..b4161268d 100644
--- a/src/borg/testsuite/chunker_pytest.py
+++ b/src/borg/testsuite/chunker_pytest.py
@@ -12,37 +12,27 @@ BS = 4096  # fs block size
 
 # some sparse files. X = content blocks, _ = sparse blocks.
 # X__XXX____
-map_sparse1 = [
-    (0 * BS, 1 * BS, True),
-    (1 * BS, 2 * BS, False),
-    (3 * BS, 3 * BS, True),
-    (6 * BS, 4 * BS, False),
-]
+map_sparse1 = [(0 * BS, 1 * BS, True), (1 * BS, 2 * BS, False), (3 * BS, 3 * BS, True), (6 * BS, 4 * BS, False)]
 
 # _XX___XXXX
-map_sparse2 = [
-    (0 * BS, 1 * BS, False),
-    (1 * BS, 2 * BS, True),
-    (3 * BS, 3 * BS, False),
-    (6 * BS, 4 * BS, True),
-]
+map_sparse2 = [(0 * BS, 1 * BS, False), (1 * BS, 2 * BS, True), (3 * BS, 3 * BS, False), (6 * BS, 4 * BS, True)]
 
 # XXX
-map_notsparse = [(0 * BS, 3 * BS, True), ]
+map_notsparse = [(0 * BS, 3 * BS, True)]
 
 # ___
-map_onlysparse = [(0 * BS, 3 * BS, False), ]
+map_onlysparse = [(0 * BS, 3 * BS, False)]
 
 
 def make_sparsefile(fname, sparsemap, header_size=0):
-    with open(fname, 'wb') as fd:
+    with open(fname, "wb") as fd:
         total = 0
         if header_size:
-            fd.write(b'H' * header_size)
+            fd.write(b"H" * header_size)
             total += header_size
         for offset, size, is_data in sparsemap:
             if is_data:
-                fd.write(b'X' * size)
+                fd.write(b"X" * size)
             else:
                 fd.seek(size, os.SEEK_CUR)
             total += size
@@ -54,11 +44,11 @@ def make_content(sparsemap, header_size=0):
     result = []
     total = 0
     if header_size:
-        result.append(b'H' * header_size)
+        result.append(b"H" * header_size)
         total += header_size
     for offset, size, is_data in sparsemap:
         if is_data:
-            result.append(b'X' * size)  # bytes!
+            result.append(b"X" * size)  # bytes!
         else:
             result.append(size)  # int!
         total += size
@@ -69,9 +59,9 @@ def fs_supports_sparse():
     if not has_seek_hole:
         return False
     with tempfile.TemporaryDirectory() as tmpdir:
-        fn = os.path.join(tmpdir, 'test_sparse')
+        fn = os.path.join(tmpdir, "test_sparse")
         make_sparsefile(fn, [(0, BS, False), (BS, BS, True)])
-        with open(fn, 'rb') as f:
+        with open(fn, "rb") as f:
             try:
                 offset_hole = f.seek(0, os.SEEK_HOLE)
                 offset_data = f.seek(0, os.SEEK_DATA)
@@ -81,15 +71,12 @@ def fs_supports_sparse():
         return offset_hole == 0 and offset_data == BS
 
 
-@pytest.mark.skipif(not fs_supports_sparse(), reason='fs does not support sparse files')
-@pytest.mark.parametrize("fname, sparse_map", [
-    ('sparse1', map_sparse1),
-    ('sparse2', map_sparse2),
-    ('onlysparse', map_onlysparse),
-    ('notsparse', map_notsparse),
-])
+@pytest.mark.skipif(not fs_supports_sparse(), reason="fs does not support sparse files")
+@pytest.mark.parametrize(
+    "fname, sparse_map",
+    [("sparse1", map_sparse1), ("sparse2", map_sparse2), ("onlysparse", map_onlysparse), ("notsparse", map_notsparse)],
+)
 def test_sparsemap(tmpdir, fname, sparse_map):
-
     def get_sparsemap_fh(fname):
         fh = os.open(fname, flags=os.O_RDONLY)
         try:
@@ -98,7 +85,7 @@ def test_sparsemap(tmpdir, fname, sparse_map):
             os.close(fh)
 
     def get_sparsemap_fd(fname):
-        with open(fname, 'rb') as fd:
+        with open(fname, "rb") as fd:
             return list(sparsemap(fd=fd))
 
     fn = str(tmpdir / fname)
@@ -107,30 +94,32 @@ def test_sparsemap(tmpdir, fname, sparse_map):
     assert get_sparsemap_fd(fn) == sparse_map
 
 
-@pytest.mark.skipif(not fs_supports_sparse(), reason='fs does not support sparse files')
-@pytest.mark.parametrize("fname, sparse_map, header_size, sparse", [
-    ('sparse1', map_sparse1, 0, False),
-    ('sparse1', map_sparse1, 0, True),
-    ('sparse1', map_sparse1, BS, False),
-    ('sparse1', map_sparse1, BS, True),
-    ('sparse2', map_sparse2, 0, False),
-    ('sparse2', map_sparse2, 0, True),
-    ('sparse2', map_sparse2, BS, False),
-    ('sparse2', map_sparse2, BS, True),
-    ('onlysparse', map_onlysparse, 0, False),
-    ('onlysparse', map_onlysparse, 0, True),
-    ('onlysparse', map_onlysparse, BS, False),
-    ('onlysparse', map_onlysparse, BS, True),
-    ('notsparse', map_notsparse, 0, False),
-    ('notsparse', map_notsparse, 0, True),
-    ('notsparse', map_notsparse, BS, False),
-    ('notsparse', map_notsparse, BS, True),
-])
+@pytest.mark.skipif(not fs_supports_sparse(), reason="fs does not support sparse files")
+@pytest.mark.parametrize(
+    "fname, sparse_map, header_size, sparse",
+    [
+        ("sparse1", map_sparse1, 0, False),
+        ("sparse1", map_sparse1, 0, True),
+        ("sparse1", map_sparse1, BS, False),
+        ("sparse1", map_sparse1, BS, True),
+        ("sparse2", map_sparse2, 0, False),
+        ("sparse2", map_sparse2, 0, True),
+        ("sparse2", map_sparse2, BS, False),
+        ("sparse2", map_sparse2, BS, True),
+        ("onlysparse", map_onlysparse, 0, False),
+        ("onlysparse", map_onlysparse, 0, True),
+        ("onlysparse", map_onlysparse, BS, False),
+        ("onlysparse", map_onlysparse, BS, True),
+        ("notsparse", map_notsparse, 0, False),
+        ("notsparse", map_notsparse, 0, True),
+        ("notsparse", map_notsparse, BS, False),
+        ("notsparse", map_notsparse, BS, True),
+    ],
+)
 def test_chunkify_sparse(tmpdir, fname, sparse_map, header_size, sparse):
-
     def get_chunks(fname, sparse, header_size):
         chunker = ChunkerFixed(4096, header_size=header_size, sparse=sparse)
-        with open(fname, 'rb') as fd:
+        with open(fname, "rb") as fd:
             return cf(chunker.chunkify(fd))
 
     fn = str(tmpdir / fname)
diff --git a/src/borg/testsuite/chunker_slow.py b/src/borg/testsuite/chunker_slow.py
index 4247e2730..9b5e27613 100644
--- a/src/borg/testsuite/chunker_slow.py
+++ b/src/borg/testsuite/chunker_slow.py
@@ -9,7 +9,6 @@ from . import BaseTestCase
 
 
 class ChunkerRegressionTestCase(BaseTestCase):
-
     def test_chunkpoints_unchanged(self):
         def twist(size):
             x = 1
@@ -31,10 +30,10 @@ class ChunkerRegressionTestCase(BaseTestCase):
                         for seed in (1849058162, 1234567653):
                             fh = BytesIO(data)
                             chunker = Chunker(seed, minexp, maxexp, maskbits, winsize)
-                            chunks = [blake2b_256(b'', c) for c in cf(chunker.chunkify(fh, -1))]
-                            runs.append(blake2b_256(b'', b''.join(chunks)))
+                            chunks = [blake2b_256(b"", c) for c in cf(chunker.chunkify(fh, -1))]
+                            runs.append(blake2b_256(b"", b"".join(chunks)))
 
         # The "correct" hash below matches the existing chunker behavior.
         # Future chunker optimisations must not change this, or existing repos will bloat.
-        overall_hash = blake2b_256(b'', b''.join(runs))
+        overall_hash = blake2b_256(b"", b"".join(runs))
         self.assert_equal(overall_hash, unhexlify("b559b0ac8df8daaa221201d018815114241ea5c6609d98913cd2246a702af4e3"))
diff --git a/src/borg/testsuite/compress.py b/src/borg/testsuite/compress.py
index 4d6cdafc8..ad383ab0f 100644
--- a/src/borg/testsuite/compress.py
+++ b/src/borg/testsuite/compress.py
@@ -1,5 +1,6 @@
 import os
 import zlib
+
 try:
     import lzma
 except ImportError:
@@ -11,23 +12,23 @@ from ..compress import get_compressor, Compressor, CompressionSpec, CNONE, ZLIB,
 
 
 buffer = bytes(2**16)
-data = b'fooooooooobaaaaaaaar' * 10
-params = dict(name='zlib', level=6)
+data = b"fooooooooobaaaaaaaar" * 10
+params = dict(name="zlib", level=6)
 
 
 def test_get_compressor():
-    c = get_compressor(name='none')
+    c = get_compressor(name="none")
     assert isinstance(c, CNONE)
-    c = get_compressor(name='lz4')
+    c = get_compressor(name="lz4")
     assert isinstance(c, LZ4)
-    c = get_compressor(name='zlib')
+    c = get_compressor(name="zlib")
     assert isinstance(c, ZLIB)
     with pytest.raises(KeyError):
-        get_compressor(name='foobar')
+        get_compressor(name="foobar")
 
 
 def test_cnull():
-    c = get_compressor(name='none')
+    c = get_compressor(name="none")
     cdata = c.compress(data)
     assert len(cdata) > len(data)
     assert data in cdata  # it's not compressed and just in there 1:1
@@ -36,7 +37,7 @@ def test_cnull():
 
 
 def test_lz4():
-    c = get_compressor(name='lz4')
+    c = get_compressor(name="lz4")
     cdata = c.compress(data)
     assert len(cdata) < len(data)
     assert data == c.decompress(cdata)
@@ -45,18 +46,18 @@ def test_lz4():
 
 def test_lz4_buffer_allocation(monkeypatch):
     # disable fallback to no compression on incompressible data
-    monkeypatch.setattr(LZ4, 'decide', lambda always_compress: LZ4)
+    monkeypatch.setattr(LZ4, "decide", lambda always_compress: LZ4)
     # test with a rather huge data object to see if buffer allocation / resizing works
     data = os.urandom(5 * 2**20) * 10  # 50MiB badly compressible data
     assert len(data) == 50 * 2**20
-    c = Compressor('lz4')
+    c = Compressor("lz4")
     cdata = c.compress(data)
     assert len(cdata) > len(data)
     assert data == c.decompress(cdata)
 
 
 def test_zlib():
-    c = get_compressor(name='zlib')
+    c = get_compressor(name="zlib")
     cdata = c.compress(data)
     assert len(cdata) < len(data)
     assert data == c.decompress(cdata)
@@ -66,7 +67,7 @@ def test_zlib():
 def test_lzma():
     if lzma is None:
         pytest.skip("No lzma support found.")
-    c = get_compressor(name='lzma')
+    c = get_compressor(name="lzma")
     cdata = c.compress(data)
     assert len(cdata) < len(data)
     assert data == c.decompress(cdata)
@@ -74,7 +75,7 @@ def test_lzma():
 
 
 def test_zstd():
-    c = get_compressor(name='zstd')
+    c = get_compressor(name="zstd")
     cdata = c.compress(data)
     assert len(cdata) < len(data)
     assert data == c.decompress(cdata)
@@ -83,16 +84,16 @@ def test_zstd():
 
 def test_autodetect_invalid():
     with pytest.raises(ValueError):
-        Compressor(**params).decompress(b'\xff\xfftotalcrap')
+        Compressor(**params).decompress(b"\xff\xfftotalcrap")
     with pytest.raises(ValueError):
-        Compressor(**params).decompress(b'\x08\x00notreallyzlib')
+        Compressor(**params).decompress(b"\x08\x00notreallyzlib")
 
 
 def test_zlib_legacy_compat():
     # for compatibility reasons, we do not add an extra header for zlib,
     # nor do we expect one when decompressing / autodetecting
     for level in range(10):
-        c = get_compressor(name='zlib_legacy', level=level)
+        c = get_compressor(name="zlib_legacy", level=level)
         cdata1 = c.compress(data)
         cdata2 = zlib.compress(data, level)
         assert cdata1 == cdata2
@@ -104,19 +105,19 @@ def test_zlib_legacy_compat():
 
 def test_compressor():
     params_list = [
-        dict(name='none'),
-        dict(name='lz4'),
-        dict(name='zstd', level=1),
-        dict(name='zstd', level=3),
+        dict(name="none"),
+        dict(name="lz4"),
+        dict(name="zstd", level=1),
+        dict(name="zstd", level=3),
         # avoiding high zstd levels, memory needs unclear
-        dict(name='zlib', level=0),
-        dict(name='zlib', level=6),
-        dict(name='zlib', level=9),
+        dict(name="zlib", level=0),
+        dict(name="zlib", level=6),
+        dict(name="zlib", level=9),
     ]
     if lzma:
         params_list += [
-            dict(name='lzma', level=0),
-            dict(name='lzma', level=6),
+            dict(name="lzma", level=0),
+            dict(name="lzma", level=6),
             # we do not test lzma on level 9 because of the huge memory needs
         ]
     for params in params_list:
@@ -125,9 +126,9 @@ def test_compressor():
 
 
 def test_auto():
-    compressor_auto_zlib = CompressionSpec('auto,zlib,9').compressor
-    compressor_lz4 = CompressionSpec('lz4').compressor
-    compressor_zlib = CompressionSpec('zlib,9').compressor
+    compressor_auto_zlib = CompressionSpec("auto,zlib,9").compressor
+    compressor_lz4 = CompressionSpec("lz4").compressor
+    compressor_zlib = CompressionSpec("zlib,9").compressor
     data = bytes(500)
     compressed_auto_zlib = compressor_auto_zlib.compress(data)
     compressed_lz4 = compressor_lz4.compress(data)
@@ -135,13 +136,13 @@ def test_auto():
     ratio = len(compressed_zlib) / len(compressed_lz4)
     assert Compressor.detect(compressed_auto_zlib)[0] == ZLIB if ratio < 0.99 else LZ4
 
-    data = b'\x00\xb8\xa3\xa2-O\xe1i\xb6\x12\x03\xc21\xf3\x8a\xf78\\\x01\xa5b\x07\x95\xbeE\xf8\xa3\x9ahm\xb1~'
+    data = b"\x00\xb8\xa3\xa2-O\xe1i\xb6\x12\x03\xc21\xf3\x8a\xf78\\\x01\xa5b\x07\x95\xbeE\xf8\xa3\x9ahm\xb1~"
     compressed = compressor_auto_zlib.compress(data)
     assert Compressor.detect(compressed)[0] == CNONE
 
 
 def test_obfuscate():
-    compressor = CompressionSpec('obfuscate,1,none').compressor
+    compressor = CompressionSpec("obfuscate,1,none").compressor
     data = bytes(10000)
     compressed = compressor.compress(data)
     # 2 id bytes compression, 2 id bytes obfuscator. 4 length bytes
@@ -149,7 +150,7 @@ def test_obfuscate():
     # compressing 100 times the same data should give at least 50 different result sizes
     assert len({len(compressor.compress(data)) for i in range(100)}) > 50
 
-    cs = CompressionSpec('obfuscate,2,lz4')
+    cs = CompressionSpec("obfuscate,2,lz4")
     assert isinstance(cs.inner.compressor, LZ4)
     compressor = cs.compressor
     data = bytes(10000)
@@ -160,7 +161,7 @@ def test_obfuscate():
     # compressing 100 times the same data should give multiple different result sizes
     assert len({len(compressor.compress(data)) for i in range(100)}) > 10
 
-    cs = CompressionSpec('obfuscate,6,zstd,3')
+    cs = CompressionSpec("obfuscate,6,zstd,3")
     assert isinstance(cs.inner.compressor, ZSTD)
     compressor = cs.compressor
     data = bytes(10000)
@@ -171,7 +172,7 @@ def test_obfuscate():
     # compressing 100 times the same data should give multiple different result sizes
     assert len({len(compressor.compress(data)) for i in range(100)}) > 90
 
-    cs = CompressionSpec('obfuscate,2,auto,zstd,10')
+    cs = CompressionSpec("obfuscate,2,auto,zstd,10")
     assert isinstance(cs.inner.compressor, Auto)
     compressor = cs.compressor
     data = bytes(10000)
@@ -182,7 +183,7 @@ def test_obfuscate():
     # compressing 100 times the same data should give multiple different result sizes
     assert len({len(compressor.compress(data)) for i in range(100)}) > 10
 
-    cs = CompressionSpec('obfuscate,110,none')
+    cs = CompressionSpec("obfuscate,110,none")
     assert isinstance(cs.inner.compressor, CNONE)
     compressor = cs.compressor
     data = bytes(1000)
@@ -199,44 +200,44 @@ def test_obfuscate():
 
 def test_compression_specs():
     with pytest.raises(ValueError):
-        CompressionSpec('')
+        CompressionSpec("")
 
-    assert isinstance(CompressionSpec('none').compressor, CNONE)
-    assert isinstance(CompressionSpec('lz4').compressor, LZ4)
+    assert isinstance(CompressionSpec("none").compressor, CNONE)
+    assert isinstance(CompressionSpec("lz4").compressor, LZ4)
 
-    zlib = CompressionSpec('zlib').compressor
+    zlib = CompressionSpec("zlib").compressor
     assert isinstance(zlib, ZLIB)
     assert zlib.level == 6
-    zlib = CompressionSpec('zlib,0').compressor
+    zlib = CompressionSpec("zlib,0").compressor
     assert isinstance(zlib, ZLIB)
     assert zlib.level == 0
-    zlib = CompressionSpec('zlib,9').compressor
+    zlib = CompressionSpec("zlib,9").compressor
     assert isinstance(zlib, ZLIB)
     assert zlib.level == 9
     with pytest.raises(ValueError):
-        CompressionSpec('zlib,9,invalid')
+        CompressionSpec("zlib,9,invalid")
 
-    lzma = CompressionSpec('lzma').compressor
+    lzma = CompressionSpec("lzma").compressor
     assert isinstance(lzma, LZMA)
     assert lzma.level == 6
-    lzma = CompressionSpec('lzma,0').compressor
+    lzma = CompressionSpec("lzma,0").compressor
     assert isinstance(lzma, LZMA)
     assert lzma.level == 0
-    lzma = CompressionSpec('lzma,9').compressor
+    lzma = CompressionSpec("lzma,9").compressor
     assert isinstance(lzma, LZMA)
     assert lzma.level == 9
 
-    zstd = CompressionSpec('zstd').compressor
+    zstd = CompressionSpec("zstd").compressor
     assert isinstance(zstd, ZSTD)
     assert zstd.level == 3
-    zstd = CompressionSpec('zstd,1').compressor
+    zstd = CompressionSpec("zstd,1").compressor
     assert isinstance(zstd, ZSTD)
     assert zstd.level == 1
-    zstd = CompressionSpec('zstd,22').compressor
+    zstd = CompressionSpec("zstd,22").compressor
     assert isinstance(zstd, ZSTD)
     assert zstd.level == 22
 
     with pytest.raises(ValueError):
-        CompressionSpec('lzma,9,invalid')
+        CompressionSpec("lzma,9,invalid")
     with pytest.raises(ValueError):
-        CompressionSpec('invalid')
+        CompressionSpec("invalid")
diff --git a/src/borg/testsuite/crypto.py b/src/borg/testsuite/crypto.py
index e131f63ac..78a6c8949 100644
--- a/src/borg/testsuite/crypto.py
+++ b/src/borg/testsuite/crypto.py
@@ -16,18 +16,17 @@ from . import BaseTestCase
 
 
 class CryptoTestCase(BaseTestCase):
-
     def test_bytes_to_int(self):
-        self.assert_equal(bytes_to_int(b'\0\0\0\1'), 1)
+        self.assert_equal(bytes_to_int(b"\0\0\0\1"), 1)
 
     def test_bytes_to_long(self):
-        self.assert_equal(bytes_to_long(b'\0\0\0\0\0\0\0\1'), 1)
-        self.assert_equal(long_to_bytes(1), b'\0\0\0\0\0\0\0\1')
+        self.assert_equal(bytes_to_long(b"\0\0\0\0\0\0\0\1"), 1)
+        self.assert_equal(long_to_bytes(1), b"\0\0\0\0\0\0\0\1")
 
     def test_UNENCRYPTED(self):
-        iv = b''  # any IV is ok, it just must be set and not None
-        data = b'data'
-        header = b'header'
+        iv = b""  # any IV is ok, it just must be set and not None
+        data = b"data"
+        header = b"header"
         cs = UNENCRYPTED(None, None, iv, header_len=6)
         envelope = cs.encrypt(data, header=header)
         self.assert_equal(envelope, header + data)
@@ -36,11 +35,11 @@ class CryptoTestCase(BaseTestCase):
 
     def test_AES256_CTR_HMAC_SHA256(self):
         # this tests the layout as in attic / borg < 1.2 (1 type byte, no aad)
-        mac_key = b'Y' * 32
-        enc_key = b'X' * 32
+        mac_key = b"Y" * 32
+        enc_key = b"X" * 32
         iv = 0
-        data = b'foo' * 10
-        header = b'\x42'
+        data = b"foo" * 10
+        header = b"\x42"
         # encrypt-then-mac
         cs = AES256_CTR_HMAC_SHA256(mac_key, enc_key, iv, header_len=1, aad_offset=1)
         hdr_mac_iv_cdata = cs.encrypt(data, header=header)
@@ -48,10 +47,10 @@ class CryptoTestCase(BaseTestCase):
         mac = hdr_mac_iv_cdata[1:33]
         iv = hdr_mac_iv_cdata[33:41]
         cdata = hdr_mac_iv_cdata[41:]
-        self.assert_equal(hexlify(hdr), b'42')
-        self.assert_equal(hexlify(mac), b'af90b488b0cc4a8f768fe2d6814fa65aec66b148135e54f7d4d29a27f22f57a8')
-        self.assert_equal(hexlify(iv), b'0000000000000000')
-        self.assert_equal(hexlify(cdata), b'c6efb702de12498f34a2c2bbc8149e759996d08bf6dc5c610aefc0c3a466')
+        self.assert_equal(hexlify(hdr), b"42")
+        self.assert_equal(hexlify(mac), b"af90b488b0cc4a8f768fe2d6814fa65aec66b148135e54f7d4d29a27f22f57a8")
+        self.assert_equal(hexlify(iv), b"0000000000000000")
+        self.assert_equal(hexlify(cdata), b"c6efb702de12498f34a2c2bbc8149e759996d08bf6dc5c610aefc0c3a466")
         self.assert_equal(cs.next_iv(), 2)
         # auth-then-decrypt
         cs = AES256_CTR_HMAC_SHA256(mac_key, enc_key, header_len=len(header), aad_offset=1)
@@ -60,16 +59,15 @@ class CryptoTestCase(BaseTestCase):
         self.assert_equal(cs.next_iv(), 2)
         # auth-failure due to corruption (corrupted data)
         cs = AES256_CTR_HMAC_SHA256(mac_key, enc_key, header_len=len(header), aad_offset=1)
-        hdr_mac_iv_cdata_corrupted = hdr_mac_iv_cdata[:41] + b'\0' + hdr_mac_iv_cdata[42:]
-        self.assert_raises(IntegrityError,
-                           lambda: cs.decrypt(hdr_mac_iv_cdata_corrupted))
+        hdr_mac_iv_cdata_corrupted = hdr_mac_iv_cdata[:41] + b"\0" + hdr_mac_iv_cdata[42:]
+        self.assert_raises(IntegrityError, lambda: cs.decrypt(hdr_mac_iv_cdata_corrupted))
 
     def test_AES256_CTR_HMAC_SHA256_aad(self):
-        mac_key = b'Y' * 32
-        enc_key = b'X' * 32
+        mac_key = b"Y" * 32
+        enc_key = b"X" * 32
         iv = 0
-        data = b'foo' * 10
-        header = b'\x12\x34\x56'
+        data = b"foo" * 10
+        header = b"\x12\x34\x56"
         # encrypt-then-mac
         cs = AES256_CTR_HMAC_SHA256(mac_key, enc_key, iv, header_len=3, aad_offset=1)
         hdr_mac_iv_cdata = cs.encrypt(data, header=header)
@@ -77,10 +75,10 @@ class CryptoTestCase(BaseTestCase):
         mac = hdr_mac_iv_cdata[3:35]
         iv = hdr_mac_iv_cdata[35:43]
         cdata = hdr_mac_iv_cdata[43:]
-        self.assert_equal(hexlify(hdr), b'123456')
-        self.assert_equal(hexlify(mac), b'7659a915d9927072ef130258052351a17ef882692893c3850dd798c03d2dd138')
-        self.assert_equal(hexlify(iv), b'0000000000000000')
-        self.assert_equal(hexlify(cdata), b'c6efb702de12498f34a2c2bbc8149e759996d08bf6dc5c610aefc0c3a466')
+        self.assert_equal(hexlify(hdr), b"123456")
+        self.assert_equal(hexlify(mac), b"7659a915d9927072ef130258052351a17ef882692893c3850dd798c03d2dd138")
+        self.assert_equal(hexlify(iv), b"0000000000000000")
+        self.assert_equal(hexlify(cdata), b"c6efb702de12498f34a2c2bbc8149e759996d08bf6dc5c610aefc0c3a466")
         self.assert_equal(cs.next_iv(), 2)
         # auth-then-decrypt
         cs = AES256_CTR_HMAC_SHA256(mac_key, enc_key, header_len=len(header), aad_offset=1)
@@ -89,24 +87,27 @@ class CryptoTestCase(BaseTestCase):
         self.assert_equal(cs.next_iv(), 2)
         # auth-failure due to corruption (corrupted aad)
         cs = AES256_CTR_HMAC_SHA256(mac_key, enc_key, header_len=len(header), aad_offset=1)
-        hdr_mac_iv_cdata_corrupted = hdr_mac_iv_cdata[:1] + b'\0' + hdr_mac_iv_cdata[2:]
-        self.assert_raises(IntegrityError,
-                           lambda: cs.decrypt(hdr_mac_iv_cdata_corrupted))
+        hdr_mac_iv_cdata_corrupted = hdr_mac_iv_cdata[:1] + b"\0" + hdr_mac_iv_cdata[2:]
+        self.assert_raises(IntegrityError, lambda: cs.decrypt(hdr_mac_iv_cdata_corrupted))
 
     def test_AE(self):
         # used in legacy-like layout (1 type byte, no aad)
-        key = b'X' * 32
+        key = b"X" * 32
         iv_int = 0
-        data = b'foo' * 10
-        header = b'\x23' + iv_int.to_bytes(12, 'big')
+        data = b"foo" * 10
+        header = b"\x23" + iv_int.to_bytes(12, "big")
         tests = [
             # (ciphersuite class, exp_mac, exp_cdata)
-            (AES256_OCB,
-             b'b6909c23c9aaebd9abbe1ff42097652d',
-             b'877ce46d2f62dee54699cebc3ba41d9ab613f7c486778c1b3636664b1493', ),
-            (CHACHA20_POLY1305,
-             b'fd08594796e0706cde1e8b461e3e0555',
-             b'a093e4b0387526f085d3c40cca84a35230a5c0dd766453b77ba38bcff775', )
+            (
+                AES256_OCB,
+                b"b6909c23c9aaebd9abbe1ff42097652d",
+                b"877ce46d2f62dee54699cebc3ba41d9ab613f7c486778c1b3636664b1493",
+            ),
+            (
+                CHACHA20_POLY1305,
+                b"fd08594796e0706cde1e8b461e3e0555",
+                b"a093e4b0387526f085d3c40cca84a35230a5c0dd766453b77ba38bcff775",
+            ),
         ]
         for cs_cls, exp_mac, exp_cdata in tests:
             # print(repr(cs_cls))
@@ -117,9 +118,9 @@ class CryptoTestCase(BaseTestCase):
             iv = hdr_mac_iv_cdata[1:13]
             mac = hdr_mac_iv_cdata[13:29]
             cdata = hdr_mac_iv_cdata[29:]
-            self.assert_equal(hexlify(hdr), b'23')
+            self.assert_equal(hexlify(hdr), b"23")
             self.assert_equal(hexlify(mac), exp_mac)
-            self.assert_equal(hexlify(iv), b'000000000000000000000000')
+            self.assert_equal(hexlify(iv), b"000000000000000000000000")
             self.assert_equal(hexlify(cdata), exp_cdata)
             self.assert_equal(cs.next_iv(), 1)
             # auth/decrypt
@@ -129,24 +130,27 @@ class CryptoTestCase(BaseTestCase):
             self.assert_equal(cs.next_iv(), 1)
             # auth-failure due to corruption (corrupted data)
             cs = cs_cls(key, iv_int, header_len=len(header), aad_offset=1)
-            hdr_mac_iv_cdata_corrupted = hdr_mac_iv_cdata[:29] + b'\0' + hdr_mac_iv_cdata[30:]
-            self.assert_raises(IntegrityError,
-                               lambda: cs.decrypt(hdr_mac_iv_cdata_corrupted))
+            hdr_mac_iv_cdata_corrupted = hdr_mac_iv_cdata[:29] + b"\0" + hdr_mac_iv_cdata[30:]
+            self.assert_raises(IntegrityError, lambda: cs.decrypt(hdr_mac_iv_cdata_corrupted))
 
     def test_AEAD(self):
         # test with aad
-        key = b'X' * 32
+        key = b"X" * 32
         iv_int = 0
-        data = b'foo' * 10
-        header = b'\x12\x34\x56' + iv_int.to_bytes(12, 'big')
+        data = b"foo" * 10
+        header = b"\x12\x34\x56" + iv_int.to_bytes(12, "big")
         tests = [
             # (ciphersuite class, exp_mac, exp_cdata)
-            (AES256_OCB,
-             b'f2748c412af1c7ead81863a18c2c1893',
-             b'877ce46d2f62dee54699cebc3ba41d9ab613f7c486778c1b3636664b1493', ),
-            (CHACHA20_POLY1305,
-             b'b7e7c9a79f2404e14f9aad156bf091dd',
-             b'a093e4b0387526f085d3c40cca84a35230a5c0dd766453b77ba38bcff775', )
+            (
+                AES256_OCB,
+                b"f2748c412af1c7ead81863a18c2c1893",
+                b"877ce46d2f62dee54699cebc3ba41d9ab613f7c486778c1b3636664b1493",
+            ),
+            (
+                CHACHA20_POLY1305,
+                b"b7e7c9a79f2404e14f9aad156bf091dd",
+                b"a093e4b0387526f085d3c40cca84a35230a5c0dd766453b77ba38bcff775",
+            ),
         ]
         for cs_cls, exp_mac, exp_cdata in tests:
             # print(repr(cs_cls))
@@ -157,9 +161,9 @@ class CryptoTestCase(BaseTestCase):
             iv = hdr_mac_iv_cdata[3:15]
             mac = hdr_mac_iv_cdata[15:31]
             cdata = hdr_mac_iv_cdata[31:]
-            self.assert_equal(hexlify(hdr), b'123456')
+            self.assert_equal(hexlify(hdr), b"123456")
             self.assert_equal(hexlify(mac), exp_mac)
-            self.assert_equal(hexlify(iv), b'000000000000000000000000')
+            self.assert_equal(hexlify(iv), b"000000000000000000000000")
             self.assert_equal(hexlify(cdata), exp_cdata)
             self.assert_equal(cs.next_iv(), 1)
             # auth/decrypt
@@ -169,101 +173,117 @@ class CryptoTestCase(BaseTestCase):
             self.assert_equal(cs.next_iv(), 1)
             # auth-failure due to corruption (corrupted aad)
             cs = cs_cls(key, iv_int, header_len=len(header), aad_offset=1)
-            hdr_mac_iv_cdata_corrupted = hdr_mac_iv_cdata[:1] + b'\0' + hdr_mac_iv_cdata[2:]
-            self.assert_raises(IntegrityError,
-                               lambda: cs.decrypt(hdr_mac_iv_cdata_corrupted))
+            hdr_mac_iv_cdata_corrupted = hdr_mac_iv_cdata[:1] + b"\0" + hdr_mac_iv_cdata[2:]
+            self.assert_raises(IntegrityError, lambda: cs.decrypt(hdr_mac_iv_cdata_corrupted))
 
     def test_AEAD_with_more_AAD(self):
         # test giving extra aad to the .encrypt() and .decrypt() calls
-        key = b'X' * 32
+        key = b"X" * 32
         iv_int = 0
-        data = b'foo' * 10
-        header = b'\x12\x34'
+        data = b"foo" * 10
+        header = b"\x12\x34"
         tests = [AES256_OCB, CHACHA20_POLY1305]
         for cs_cls in tests:
             # encrypt/mac
             cs = cs_cls(key, iv_int, header_len=len(header), aad_offset=0)
-            hdr_mac_iv_cdata = cs.encrypt(data, header=header, aad=b'correct_chunkid')
+            hdr_mac_iv_cdata = cs.encrypt(data, header=header, aad=b"correct_chunkid")
             # successful auth/decrypt (correct aad)
             cs = cs_cls(key, iv_int, header_len=len(header), aad_offset=0)
-            pdata = cs.decrypt(hdr_mac_iv_cdata, aad=b'correct_chunkid')
+            pdata = cs.decrypt(hdr_mac_iv_cdata, aad=b"correct_chunkid")
             self.assert_equal(data, pdata)
             # unsuccessful auth (incorrect aad)
             cs = cs_cls(key, iv_int, header_len=len(header), aad_offset=0)
-            self.assert_raises(IntegrityError,
-                               lambda: cs.decrypt(hdr_mac_iv_cdata, aad=b'incorrect_chunkid'))
+            self.assert_raises(IntegrityError, lambda: cs.decrypt(hdr_mac_iv_cdata, aad=b"incorrect_chunkid"))
 
     # These test vectors come from https://www.kullo.net/blog/hkdf-sha-512-test-vectors/
     # who claims to have verified these against independent Python and C++ implementations.
 
     def test_hkdf_hmac_sha512(self):
-        ikm = b'\x0b' * 22
-        salt = bytes.fromhex('000102030405060708090a0b0c')
-        info = bytes.fromhex('f0f1f2f3f4f5f6f7f8f9')
+        ikm = b"\x0b" * 22
+        salt = bytes.fromhex("000102030405060708090a0b0c")
+        info = bytes.fromhex("f0f1f2f3f4f5f6f7f8f9")
         l = 42
 
         okm = hkdf_hmac_sha512(ikm, salt, info, l)
-        assert okm == bytes.fromhex('832390086cda71fb47625bb5ceb168e4c8e26a1a16ed34d9fc7fe92c1481579338da362cb8d9f925d7cb')
+        assert okm == bytes.fromhex(
+            "832390086cda71fb47625bb5ceb168e4c8e26a1a16ed34d9fc7fe92c1481579338da362cb8d9f925d7cb"
+        )
 
     def test_hkdf_hmac_sha512_2(self):
-        ikm = bytes.fromhex('000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f2021222324252627'
-                            '28292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f')
-        salt = bytes.fromhex('606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868'
-                             '788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeaf')
-        info = bytes.fromhex('b0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7'
-                             'd8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff')
+        ikm = bytes.fromhex(
+            "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f2021222324252627"
+            "28292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f"
+        )
+        salt = bytes.fromhex(
+            "606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868"
+            "788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeaf"
+        )
+        info = bytes.fromhex(
+            "b0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7"
+            "d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff"
+        )
         l = 82
 
         okm = hkdf_hmac_sha512(ikm, salt, info, l)
-        assert okm == bytes.fromhex('ce6c97192805b346e6161e821ed165673b84f400a2b514b2fe23d84cd189ddf1b695b48cbd1c838844'
-                                    '1137b3ce28f16aa64ba33ba466b24df6cfcb021ecff235f6a2056ce3af1de44d572097a8505d9e7a93')
+        assert okm == bytes.fromhex(
+            "ce6c97192805b346e6161e821ed165673b84f400a2b514b2fe23d84cd189ddf1b695b48cbd1c838844"
+            "1137b3ce28f16aa64ba33ba466b24df6cfcb021ecff235f6a2056ce3af1de44d572097a8505d9e7a93"
+        )
 
     def test_hkdf_hmac_sha512_3(self):
-        ikm = bytes.fromhex('0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b')
+        ikm = bytes.fromhex("0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b")
         salt = None
-        info = b''
+        info = b""
         l = 42
 
         okm = hkdf_hmac_sha512(ikm, salt, info, l)
-        assert okm == bytes.fromhex('f5fa02b18298a72a8c23898a8703472c6eb179dc204c03425c970e3b164bf90fff22d04836d0e2343bac')
+        assert okm == bytes.fromhex(
+            "f5fa02b18298a72a8c23898a8703472c6eb179dc204c03425c970e3b164bf90fff22d04836d0e2343bac"
+        )
 
     def test_hkdf_hmac_sha512_4(self):
-        ikm = bytes.fromhex('0b0b0b0b0b0b0b0b0b0b0b')
-        salt = bytes.fromhex('000102030405060708090a0b0c')
-        info = bytes.fromhex('f0f1f2f3f4f5f6f7f8f9')
+        ikm = bytes.fromhex("0b0b0b0b0b0b0b0b0b0b0b")
+        salt = bytes.fromhex("000102030405060708090a0b0c")
+        info = bytes.fromhex("f0f1f2f3f4f5f6f7f8f9")
         l = 42
 
         okm = hkdf_hmac_sha512(ikm, salt, info, l)
-        assert okm == bytes.fromhex('7413e8997e020610fbf6823f2ce14bff01875db1ca55f68cfcf3954dc8aff53559bd5e3028b080f7c068')
+        assert okm == bytes.fromhex(
+            "7413e8997e020610fbf6823f2ce14bff01875db1ca55f68cfcf3954dc8aff53559bd5e3028b080f7c068"
+        )
 
     def test_hkdf_hmac_sha512_5(self):
-        ikm = bytes.fromhex('0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c')
+        ikm = bytes.fromhex("0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c")
         salt = None
-        info = b''
+        info = b""
         l = 42
 
         okm = hkdf_hmac_sha512(ikm, salt, info, l)
-        assert okm == bytes.fromhex('1407d46013d98bc6decefcfee55f0f90b0c7f63d68eb1a80eaf07e953cfc0a3a5240a155d6e4daa965bb')
+        assert okm == bytes.fromhex(
+            "1407d46013d98bc6decefcfee55f0f90b0c7f63d68eb1a80eaf07e953cfc0a3a5240a155d6e4daa965bb"
+        )
 
 
 def test_decrypt_key_file_argon2_chacha20_poly1305():
-    plain = b'hello'
+    plain = b"hello"
     # echo -n "hello, pass phrase" | argon2 saltsaltsaltsalt -id -t 1 -k 8 -p 1 -l 32 -r
-    key = bytes.fromhex('a1b0cba145c154fbd8960996c5ce3428e9920cfe53c84ef08b4102a70832bcec')
+    key = bytes.fromhex("a1b0cba145c154fbd8960996c5ce3428e9920cfe53c84ef08b4102a70832bcec")
     ae_cipher = CHACHA20_POLY1305(key=key, iv=0, header_len=0, aad_offset=0)
 
     envelope = ae_cipher.encrypt(plain)
 
-    encrypted = msgpack.packb({
-        'version': 1,
-        'salt': b'salt'*4,
-        'argon2_time_cost': 1,
-        'argon2_memory_cost': 8,
-        'argon2_parallelism': 1,
-        'argon2_type': b'id',
-        'algorithm': 'argon2 chacha20-poly1305',
-        'data': envelope,
-    })
+    encrypted = msgpack.packb(
+        {
+            "version": 1,
+            "salt": b"salt" * 4,
+            "argon2_time_cost": 1,
+            "argon2_memory_cost": 8,
+            "argon2_parallelism": 1,
+            "argon2_type": b"id",
+            "algorithm": "argon2 chacha20-poly1305",
+            "data": envelope,
+        }
+    )
     key = CHPOKeyfileKey(None)
 
     decrypted = key.decrypt_key_file(encrypted, "hello, pass phrase")
@@ -272,20 +292,15 @@ def test_decrypt_key_file_argon2_chacha20_poly1305():
 
 
 def test_decrypt_key_file_pbkdf2_sha256_aes256_ctr_hmac_sha256():
-    plain = b'hello'
-    salt = b'salt'*4
+    plain = b"hello"
+    salt = b"salt" * 4
     passphrase = "hello, pass phrase"
     key = FlexiKey.pbkdf2(passphrase, salt, 1, 32)
     hash = hmac_sha256(key, plain)
-    data = AES(key, b'\0'*16).encrypt(plain)
-    encrypted = msgpack.packb({
-        'version': 1,
-        'algorithm': 'sha256',
-        'iterations': 1,
-        'salt': salt,
-        'data': data,
-        'hash': hash,
-    })
+    data = AES(key, b"\0" * 16).encrypt(plain)
+    encrypted = msgpack.packb(
+        {"version": 1, "algorithm": "sha256", "iterations": 1, "salt": salt, "data": data, "hash": hash}
+    )
     key = CHPOKeyfileKey(None)
 
     decrypted = key.decrypt_key_file(encrypted, passphrase)
@@ -293,7 +308,7 @@ def test_decrypt_key_file_pbkdf2_sha256_aes256_ctr_hmac_sha256():
     assert decrypted == plain
 
 
-@unittest.mock.patch('getpass.getpass')
+@unittest.mock.patch("getpass.getpass")
 def test_repo_key_detect_does_not_raise_integrity_error(getpass, monkeypatch):
     """https://github.com/borgbackup/borg/pull/6469#discussion_r832670411
 
@@ -322,10 +337,10 @@ def test_repo_key_detect_does_not_raise_integrity_error(getpass, monkeypatch):
     2. FlexiKey.detect() relies on that interface - it tries an empty passphrase before prompting the user
     3. my initial implementation of decrypt_key_file_argon2() was simply passing through the IntegrityError() from AES256_CTR_BASE.decrypt()
     """
-    repository = MagicMock(id=b'repository_id')
+    repository = MagicMock(id=b"repository_id")
     getpass.return_value = "hello, pass phrase"
-    monkeypatch.setenv('BORG_DISPLAY_PASSPHRASE', 'no')
-    AESOCBRepoKey.create(repository, args=MagicMock(key_algorithm='argon2'))
+    monkeypatch.setenv("BORG_DISPLAY_PASSPHRASE", "no")
+    AESOCBRepoKey.create(repository, args=MagicMock(key_algorithm="argon2"))
     repository.load_key.return_value = repository.save_key.call_args.args[0]
 
     AESOCBRepoKey.detect(repository, manifest_data=None)
diff --git a/src/borg/testsuite/efficient_collection_queue.py b/src/borg/testsuite/efficient_collection_queue.py
index e23673f5e..aab2cf9b2 100644
--- a/src/borg/testsuite/efficient_collection_queue.py
+++ b/src/borg/testsuite/efficient_collection_queue.py
@@ -6,13 +6,13 @@ from ..helpers.datastruct import EfficientCollectionQueue
 class TestEfficientQueue:
     def test_base_usage(self):
         queue = EfficientCollectionQueue(100, bytes)
-        assert queue.peek_front() == b''
-        queue.push_back(b'1234')
-        assert queue.peek_front() == b'1234'
+        assert queue.peek_front() == b""
+        queue.push_back(b"1234")
+        assert queue.peek_front() == b"1234"
         assert len(queue) == 4
         assert queue
         queue.pop_front(4)
-        assert queue.peek_front() == b''
+        assert queue.peek_front() == b""
         assert len(queue) == 0
         assert not queue
 
@@ -30,22 +30,22 @@ class TestEfficientQueue:
 
     def test_chunking(self):
         queue = EfficientCollectionQueue(2, bytes)
-        queue.push_back(b'1')
-        queue.push_back(b'23')
-        queue.push_back(b'4567')
+        queue.push_back(b"1")
+        queue.push_back(b"23")
+        queue.push_back(b"4567")
         assert len(queue) == 7
-        assert queue.peek_front() == b'12'
+        assert queue.peek_front() == b"12"
         queue.pop_front(3)
-        assert queue.peek_front() == b'4'
+        assert queue.peek_front() == b"4"
         queue.pop_front(1)
-        assert queue.peek_front() == b'56'
+        assert queue.peek_front() == b"56"
         queue.pop_front(2)
         assert len(queue) == 1
         assert queue
         with pytest.raises(EfficientCollectionQueue.SizeUnderflow):
             queue.pop_front(2)
-        assert queue.peek_front() == b'7'
+        assert queue.peek_front() == b"7"
         queue.pop_front(1)
-        assert queue.peek_front() == b''
+        assert queue.peek_front() == b""
         assert len(queue) == 0
         assert not queue
diff --git a/src/borg/testsuite/file_integrity.py b/src/borg/testsuite/file_integrity.py
index af50f15c0..8249d8e6b 100644
--- a/src/borg/testsuite/file_integrity.py
+++ b/src/borg/testsuite/file_integrity.py
@@ -5,34 +5,30 @@ from ..crypto.file_integrity import IntegrityCheckedFile, DetachedIntegrityCheck
 
 class TestReadIntegrityFile:
     def test_no_integrity(self, tmpdir):
-        protected_file = tmpdir.join('file')
-        protected_file.write('1234')
+        protected_file = tmpdir.join("file")
+        protected_file.write("1234")
         assert DetachedIntegrityCheckedFile.read_integrity_file(str(protected_file)) is None
 
     def test_truncated_integrity(self, tmpdir):
-        protected_file = tmpdir.join('file')
-        protected_file.write('1234')
-        tmpdir.join('file.integrity').write('')
+        protected_file = tmpdir.join("file")
+        protected_file.write("1234")
+        tmpdir.join("file.integrity").write("")
         with pytest.raises(FileIntegrityError):
             DetachedIntegrityCheckedFile.read_integrity_file(str(protected_file))
 
     def test_unknown_algorithm(self, tmpdir):
-        protected_file = tmpdir.join('file')
-        protected_file.write('1234')
-        tmpdir.join('file.integrity').write('{"algorithm": "HMAC_SERIOUSHASH", "digests": "1234"}')
+        protected_file = tmpdir.join("file")
+        protected_file.write("1234")
+        tmpdir.join("file.integrity").write('{"algorithm": "HMAC_SERIOUSHASH", "digests": "1234"}')
         assert DetachedIntegrityCheckedFile.read_integrity_file(str(protected_file)) is None
 
-    @pytest.mark.parametrize('json', (
-        '{"ALGORITHM": "HMAC_SERIOUSHASH", "digests": "1234"}',
-        '[]',
-        '1234.5',
-        '"A string"',
-        'Invalid JSON',
-    ))
+    @pytest.mark.parametrize(
+        "json", ('{"ALGORITHM": "HMAC_SERIOUSHASH", "digests": "1234"}', "[]", "1234.5", '"A string"', "Invalid JSON")
+    )
     def test_malformed(self, tmpdir, json):
-        protected_file = tmpdir.join('file')
-        protected_file.write('1234')
-        tmpdir.join('file.integrity').write(json)
+        protected_file = tmpdir.join("file")
+        protected_file.write("1234")
+        tmpdir.join("file.integrity").write(json)
         with pytest.raises(FileIntegrityError):
             DetachedIntegrityCheckedFile.read_integrity_file(str(protected_file))
 
@@ -40,74 +36,71 @@ class TestReadIntegrityFile:
 class TestDetachedIntegrityCheckedFile:
     @pytest.fixture
     def integrity_protected_file(self, tmpdir):
-        path = str(tmpdir.join('file'))
+        path = str(tmpdir.join("file"))
         with DetachedIntegrityCheckedFile(path, write=True) as fd:
-            fd.write(b'foo and bar')
+            fd.write(b"foo and bar")
         return path
 
     def test_simple(self, tmpdir, integrity_protected_file):
-        assert tmpdir.join('file').check(file=True)
-        assert tmpdir.join('file.integrity').check(file=True)
+        assert tmpdir.join("file").check(file=True)
+        assert tmpdir.join("file.integrity").check(file=True)
         with DetachedIntegrityCheckedFile(integrity_protected_file, write=False) as fd:
-            assert fd.read() == b'foo and bar'
+            assert fd.read() == b"foo and bar"
 
     def test_corrupted_file(self, integrity_protected_file):
-        with open(integrity_protected_file, 'ab') as fd:
-            fd.write(b' extra data')
+        with open(integrity_protected_file, "ab") as fd:
+            fd.write(b" extra data")
         with pytest.raises(FileIntegrityError):
             with DetachedIntegrityCheckedFile(integrity_protected_file, write=False) as fd:
-                assert fd.read() == b'foo and bar extra data'
+                assert fd.read() == b"foo and bar extra data"
 
     def test_corrupted_file_partial_read(self, integrity_protected_file):
-        with open(integrity_protected_file, 'ab') as fd:
-            fd.write(b' extra data')
+        with open(integrity_protected_file, "ab") as fd:
+            fd.write(b" extra data")
         with pytest.raises(FileIntegrityError):
             with DetachedIntegrityCheckedFile(integrity_protected_file, write=False) as fd:
-                data = b'foo and bar'
+                data = b"foo and bar"
                 assert fd.read(len(data)) == data
 
-    @pytest.mark.parametrize('new_name', (
-        'different_file',
-        'different_file.different_ext',
-    ))
+    @pytest.mark.parametrize("new_name", ("different_file", "different_file.different_ext"))
     def test_renamed_file(self, tmpdir, integrity_protected_file, new_name):
         new_path = tmpdir.join(new_name)
-        tmpdir.join('file').move(new_path)
-        tmpdir.join('file.integrity').move(new_path + '.integrity')
+        tmpdir.join("file").move(new_path)
+        tmpdir.join("file.integrity").move(new_path + ".integrity")
         with pytest.raises(FileIntegrityError):
             with DetachedIntegrityCheckedFile(str(new_path), write=False) as fd:
-                assert fd.read() == b'foo and bar'
+                assert fd.read() == b"foo and bar"
 
     def test_moved_file(self, tmpdir, integrity_protected_file):
-        new_dir = tmpdir.mkdir('another_directory')
-        tmpdir.join('file').move(new_dir.join('file'))
-        tmpdir.join('file.integrity').move(new_dir.join('file.integrity'))
-        new_path = str(new_dir.join('file'))
+        new_dir = tmpdir.mkdir("another_directory")
+        tmpdir.join("file").move(new_dir.join("file"))
+        tmpdir.join("file.integrity").move(new_dir.join("file.integrity"))
+        new_path = str(new_dir.join("file"))
         with DetachedIntegrityCheckedFile(new_path, write=False) as fd:
-            assert fd.read() == b'foo and bar'
+            assert fd.read() == b"foo and bar"
 
     def test_no_integrity(self, tmpdir, integrity_protected_file):
-        tmpdir.join('file.integrity').remove()
+        tmpdir.join("file.integrity").remove()
         with DetachedIntegrityCheckedFile(integrity_protected_file, write=False) as fd:
-            assert fd.read() == b'foo and bar'
+            assert fd.read() == b"foo and bar"
 
 
 class TestDetachedIntegrityCheckedFileParts:
     @pytest.fixture
     def integrity_protected_file(self, tmpdir):
-        path = str(tmpdir.join('file'))
+        path = str(tmpdir.join("file"))
         with DetachedIntegrityCheckedFile(path, write=True) as fd:
-            fd.write(b'foo and bar')
-            fd.hash_part('foopart')
-            fd.write(b' other data')
+            fd.write(b"foo and bar")
+            fd.hash_part("foopart")
+            fd.write(b" other data")
         return path
 
     def test_simple(self, integrity_protected_file):
         with DetachedIntegrityCheckedFile(integrity_protected_file, write=False) as fd:
-            data1 = b'foo and bar'
+            data1 = b"foo and bar"
             assert fd.read(len(data1)) == data1
-            fd.hash_part('foopart')
-            assert fd.read() == b' other data'
+            fd.hash_part("foopart")
+            assert fd.read() == b" other data"
 
     def test_wrong_part_name(self, integrity_protected_file):
         with pytest.raises(FileIntegrityError):
@@ -115,25 +108,25 @@ class TestDetachedIntegrityCheckedFileParts:
             # the failing hash_part. This is intentional: (1) it makes the code simpler (2) it's a good fail-safe
             # against overly broad exception handling.
             with DetachedIntegrityCheckedFile(integrity_protected_file, write=False) as fd:
-                data1 = b'foo and bar'
+                data1 = b"foo and bar"
                 assert fd.read(len(data1)) == data1
                 with pytest.raises(FileIntegrityError):
                     # This specific bit raises it directly
-                    fd.hash_part('barpart')
+                    fd.hash_part("barpart")
                 # Still explodes in the end.
 
-    @pytest.mark.parametrize('partial_read', (False, True))
+    @pytest.mark.parametrize("partial_read", (False, True))
     def test_part_independence(self, integrity_protected_file, partial_read):
-        with open(integrity_protected_file, 'ab') as fd:
-            fd.write(b'some extra stuff that does not belong')
+        with open(integrity_protected_file, "ab") as fd:
+            fd.write(b"some extra stuff that does not belong")
         with pytest.raises(FileIntegrityError):
             with DetachedIntegrityCheckedFile(integrity_protected_file, write=False) as fd:
-                data1 = b'foo and bar'
+                data1 = b"foo and bar"
                 try:
                     assert fd.read(len(data1)) == data1
-                    fd.hash_part('foopart')
+                    fd.hash_part("foopart")
                 except FileIntegrityError:
-                    assert False, 'This part must not raise, since this part is still valid.'
+                    assert False, "This part must not raise, since this part is still valid."
                 if not partial_read:
                     fd.read()
                 # But overall it explodes with the final digest. Neat, eh?
diff --git a/src/borg/testsuite/hashindex.py b/src/borg/testsuite/hashindex.py
index b98444c3a..ce2616dc6 100644
--- a/src/borg/testsuite/hashindex.py
+++ b/src/borg/testsuite/hashindex.py
@@ -15,7 +15,7 @@ from . import BaseTestCase, unopened_tempfile
 
 def H(x):
     # make some 32byte long thing that depends on x
-    return bytes('%-0.32d' % x, 'ascii')
+    return bytes("%-0.32d" % x, "ascii")
 
 
 def H2(x):
@@ -24,7 +24,6 @@ def H2(x):
 
 
 class HashIndexTestCase(BaseTestCase):
-
     def _generic_test(self, cls, make_value, sha):
         idx = cls()
         self.assert_equal(len(idx), 0)
@@ -57,7 +56,7 @@ class HashIndexTestCase(BaseTestCase):
             idx.write(filepath)
             del idx
             # Verify file contents
-            with open(filepath, 'rb') as fd:
+            with open(filepath, "rb") as fd:
                 self.assert_equal(hashlib.sha256(fd.read()).hexdigest(), sha)
             # Make sure we can open the file
             idx = cls.read(filepath)
@@ -86,12 +85,14 @@ class HashIndexTestCase(BaseTestCase):
         del idx
 
     def test_nsindex(self):
-        self._generic_test(NSIndex, lambda x: (x, x, x),
-                           '7d70671d0b7e9d2f51b2691ecf35184b9f8ecc1202cceb2748c905c8fc04c256')
+        self._generic_test(
+            NSIndex, lambda x: (x, x, x), "7d70671d0b7e9d2f51b2691ecf35184b9f8ecc1202cceb2748c905c8fc04c256"
+        )
 
     def test_chunkindex(self):
-        self._generic_test(ChunkIndex, lambda x: (x, x),
-                           '85f72b036c692c8266e4f51ccf0cff2147204282b5e316ae508d30a448d88fef')
+        self._generic_test(
+            ChunkIndex, lambda x: (x, x), "85f72b036c692c8266e4f51ccf0cff2147204282b5e316ae508d30a448d88fef"
+        )
 
     def test_resize(self):
         n = 2000  # Must be >= MIN_BUCKETS
@@ -218,8 +219,8 @@ class HashIndexTestCase(BaseTestCase):
 
 
 class HashIndexExtraTestCase(BaseTestCase):
-    """These tests are separate because they should not become part of the selftest.
-    """
+    """These tests are separate because they should not become part of the selftest."""
+
     def test_chunk_indexer(self):
         # see _hashindex.c hash_sizes, we want to be close to the max. load
         # because interesting errors happen there.
@@ -227,7 +228,7 @@ class HashIndexExtraTestCase(BaseTestCase):
         index = ChunkIndex(key_count)
         all_keys = [hashlib.sha256(H(k)).digest() for k in range(key_count)]
         # we're gonna delete 1/3 of all_keys, so let's split them 2/3 and 1/3:
-        keys, to_delete_keys = all_keys[0:(2*key_count//3)], all_keys[(2*key_count//3):]
+        keys, to_delete_keys = all_keys[0 : (2 * key_count // 3)], all_keys[(2 * key_count // 3) :]
 
         for i, key in enumerate(keys):
             index[key] = (i, i)
@@ -286,6 +287,7 @@ class HashIndexRefcountingTestCase(BaseTestCase):
             idx1.merge(idx2)
             refcount, *_ = idx1[H(1)]
             return refcount
+
         result = merge(refcounta, refcountb)
         # check for commutativity
         assert result == merge(refcountb, refcounta)
@@ -367,22 +369,24 @@ class HashIndexRefcountingTestCase(BaseTestCase):
 
 class HashIndexDataTestCase(BaseTestCase):
     # This bytestring was created with borg2-pre 2022-06-10
-    HASHINDEX = b'eJzt0LEJg1AYhdE/JqBjOEJMNhBBrAQrO9ewc+HsoG+CPMsEz1cfbnHbceqXoZvvEVE+IuoqMu2pnOE4' \
-                b'juM4juM4juM4juM4juM4juM4juM4juM4juM4juM4juM4juM4juM4juM4juM4juM4juM4juM4juM4juM4' \
-                b'juM4juM4juM4jruie36vuSVT5N0rzW0n9t7r5z9+4TiO4ziO4ziO4ziO4ziO4ziO4ziO4ziO4ziO4ziO' \
-                b'4ziO4ziO4ziO4ziO4ziO437LHbSVHGw='
+    HASHINDEX = (
+        b"eJzt0LEJg1AYhdE/JqBjOEJMNhBBrAQrO9ewc+HsoG+CPMsEz1cfbnHbceqXoZvvEVE+IuoqMu2pnOE4"
+        b"juM4juM4juM4juM4juM4juM4juM4juM4juM4juM4juM4juM4juM4juM4juM4juM4juM4juM4juM4juM4"
+        b"juM4juM4juM4jruie36vuSVT5N0rzW0n9t7r5z9+4TiO4ziO4ziO4ziO4ziO4ziO4ziO4ziO4ziO4ziO"
+        b"4ziO4ziO4ziO4ziO4ziO437LHbSVHGw="
+    )
 
     def _serialize_hashindex(self, idx):
         with tempfile.TemporaryDirectory() as tempdir:
-            file = os.path.join(tempdir, 'idx')
+            file = os.path.join(tempdir, "idx")
             idx.write(file)
-            with open(file, 'rb') as f:
+            with open(file, "rb") as f:
                 return self._pack(f.read())
 
     def _deserialize_hashindex(self, bytestring):
         with tempfile.TemporaryDirectory() as tempdir:
-            file = os.path.join(tempdir, 'idx')
-            with open(file, 'wb') as f:
+            file = os.path.join(tempdir, "idx")
+            with open(file, "wb") as f:
                 f.write(self._unpack(bytestring))
             return ChunkIndex.read(file)
 
@@ -416,19 +420,19 @@ class HashIndexDataTestCase(BaseTestCase):
 class HashIndexIntegrityTestCase(HashIndexDataTestCase):
     def write_integrity_checked_index(self, tempdir):
         idx = self._deserialize_hashindex(self.HASHINDEX)
-        file = os.path.join(tempdir, 'idx')
+        file = os.path.join(tempdir, "idx")
         with IntegrityCheckedFile(path=file, write=True) as fd:
             idx.write(fd)
         integrity_data = fd.integrity_data
-        assert 'final' in integrity_data
-        assert 'HashHeader' in integrity_data
+        assert "final" in integrity_data
+        assert "HashHeader" in integrity_data
         return file, integrity_data
 
     def test_integrity_checked_file(self):
         with tempfile.TemporaryDirectory() as tempdir:
             file, integrity_data = self.write_integrity_checked_index(tempdir)
-            with open(file, 'r+b') as fd:
-                fd.write(b'Foo')
+            with open(file, "r+b") as fd:
+                fd.write(b"Foo")
             with self.assert_raises(FileIntegrityError):
                 with IntegrityCheckedFile(path=file, write=False, integrity_data=integrity_data) as fd:
                     ChunkIndex.read(fd)
@@ -437,15 +441,15 @@ class HashIndexIntegrityTestCase(HashIndexDataTestCase):
 class HashIndexCompactTestCase(HashIndexDataTestCase):
     def index(self, num_entries, num_buckets):
         index_data = io.BytesIO()
-        index_data.write(b'BORG_IDX')
+        index_data.write(b"BORG_IDX")
         # num_entries
-        index_data.write(num_entries.to_bytes(4, 'little'))
+        index_data.write(num_entries.to_bytes(4, "little"))
         # num_buckets
-        index_data.write(num_buckets.to_bytes(4, 'little'))
+        index_data.write(num_buckets.to_bytes(4, "little"))
         # key_size
-        index_data.write((32).to_bytes(1, 'little'))
+        index_data.write((32).to_bytes(1, "little"))
         # value_size
-        index_data.write((3 * 4).to_bytes(1, 'little'))
+        index_data.write((3 * 4).to_bytes(1, "little"))
 
         self.index_data = index_data
 
@@ -468,13 +472,13 @@ class HashIndexCompactTestCase(HashIndexDataTestCase):
     def write_entry(self, key, *values):
         self.index_data.write(key)
         for value in values:
-            self.index_data.write(value.to_bytes(4, 'little'))
+            self.index_data.write(value.to_bytes(4, "little"))
 
     def write_empty(self, key):
-        self.write_entry(key, 0xffffffff, 0, 0)
+        self.write_entry(key, 0xFFFFFFFF, 0, 0)
 
     def write_deleted(self, key):
-        self.write_entry(key, 0xfffffffe, 0, 0)
+        self.write_entry(key, 0xFFFFFFFE, 0, 0)
 
     def test_simple(self):
         self.index(num_entries=3, num_buckets=6)
@@ -600,7 +604,7 @@ class IndexCorruptionTestCase(BaseTestCase):
             # first 4 bytes. giving a specific x targets bucket index x.
             # y is to create different keys and does not go into the bucket index calculation.
             # so, same x + different y --> collision
-            return pack('<IIIIIIII', x, y, z, 0, 0, 0, 0, 0)  # 8 * 4 == 32
+            return pack("<IIIIIIII", x, y, z, 0, 0, 0, 0, 0)  # 8 * 4 == 32
 
         idx = NSIndex()
 
diff --git a/src/borg/testsuite/helpers.py b/src/borg/testsuite/helpers.py
index 7a532c9d6..11e32cf1c 100644
--- a/src/borg/testsuite/helpers.py
+++ b/src/borg/testsuite/helpers.py
@@ -14,7 +14,15 @@ from .. import platform
 from ..constants import MAX_DATA_SIZE
 from ..helpers import Location
 from ..helpers import Buffer
-from ..helpers import partial_format, format_file_size, parse_file_size, format_timedelta, format_line, PlaceholderError, replace_placeholders
+from ..helpers import (
+    partial_format,
+    format_file_size,
+    parse_file_size,
+    format_timedelta,
+    format_line,
+    PlaceholderError,
+    replace_placeholders,
+)
 from ..helpers import make_path_safe, clean_lines
 from ..helpers import interval, prune_within, prune_split
 from ..helpers import get_base_dir, get_cache_dir, get_keys_dir, get_security_dir, get_config_dir
@@ -38,187 +46,253 @@ from . import BaseTestCase, FakeInputs
 
 
 def test_bin_to_hex():
-    assert bin_to_hex(b'') == ''
-    assert bin_to_hex(b'\x00\x01\xff') == '0001ff'
+    assert bin_to_hex(b"") == ""
+    assert bin_to_hex(b"\x00\x01\xff") == "0001ff"
 
 
 class TestLocationWithoutEnv:
     @pytest.fixture
     def keys_dir(self, tmpdir, monkeypatch):
         tmpdir = str(tmpdir)
-        monkeypatch.setenv('BORG_KEYS_DIR', tmpdir)
+        monkeypatch.setenv("BORG_KEYS_DIR", tmpdir)
         if not tmpdir.endswith(os.path.sep):
             tmpdir += os.path.sep
         return tmpdir
 
     def test_ssh(self, monkeypatch, keys_dir):
-        monkeypatch.delenv('BORG_REPO', raising=False)
-        assert repr(Location('ssh://user@host:1234/some/path')) == \
-            "Location(proto='ssh', user='user', host='host', port=1234, path='/some/path')"
-        assert Location('ssh://user@host:1234/some/path').to_key_filename() == keys_dir + 'host__some_path'
-        assert repr(Location('ssh://user@host:1234/some/path')) == \
-            "Location(proto='ssh', user='user', host='host', port=1234, path='/some/path')"
-        assert repr(Location('ssh://user@host/some/path')) == \
-            "Location(proto='ssh', user='user', host='host', port=None, path='/some/path')"
-        assert repr(Location('ssh://user@[::]:1234/some/path')) == \
-            "Location(proto='ssh', user='user', host='::', port=1234, path='/some/path')"
-        assert repr(Location('ssh://user@[::]:1234/some/path')) == \
-            "Location(proto='ssh', user='user', host='::', port=1234, path='/some/path')"
-        assert Location('ssh://user@[::]:1234/some/path').to_key_filename() == keys_dir + '____some_path'
-        assert repr(Location('ssh://user@[::]/some/path')) == \
-            "Location(proto='ssh', user='user', host='::', port=None, path='/some/path')"
-        assert repr(Location('ssh://user@[2001:db8::]:1234/some/path')) == \
-            "Location(proto='ssh', user='user', host='2001:db8::', port=1234, path='/some/path')"
-        assert repr(Location('ssh://user@[2001:db8::]:1234/some/path')) == \
-            "Location(proto='ssh', user='user', host='2001:db8::', port=1234, path='/some/path')"
-        assert Location('ssh://user@[2001:db8::]:1234/some/path').to_key_filename() == keys_dir + '2001_db8____some_path'
-        assert repr(Location('ssh://user@[2001:db8::]/some/path')) == \
-            "Location(proto='ssh', user='user', host='2001:db8::', port=None, path='/some/path')"
-        assert repr(Location('ssh://user@[2001:db8::c0:ffee]:1234/some/path')) == \
-            "Location(proto='ssh', user='user', host='2001:db8::c0:ffee', port=1234, path='/some/path')"
-        assert repr(Location('ssh://user@[2001:db8::c0:ffee]:1234/some/path')) == \
-            "Location(proto='ssh', user='user', host='2001:db8::c0:ffee', port=1234, path='/some/path')"
-        assert repr(Location('ssh://user@[2001:db8::c0:ffee]/some/path')) == \
-            "Location(proto='ssh', user='user', host='2001:db8::c0:ffee', port=None, path='/some/path')"
-        assert repr(Location('ssh://user@[2001:db8::192.0.2.1]:1234/some/path')) == \
-            "Location(proto='ssh', user='user', host='2001:db8::192.0.2.1', port=1234, path='/some/path')"
-        assert repr(Location('ssh://user@[2001:db8::192.0.2.1]:1234/some/path')) == \
-            "Location(proto='ssh', user='user', host='2001:db8::192.0.2.1', port=1234, path='/some/path')"
-        assert repr(Location('ssh://user@[2001:db8::192.0.2.1]/some/path')) == \
-            "Location(proto='ssh', user='user', host='2001:db8::192.0.2.1', port=None, path='/some/path')"
-        assert Location('ssh://user@[2001:db8::192.0.2.1]/some/path').to_key_filename() == keys_dir + '2001_db8__192_0_2_1__some_path'
-        assert repr(Location('ssh://user@[2a02:0001:0002:0003:0004:0005:0006:0007]/some/path')) == \
-            "Location(proto='ssh', user='user', host='2a02:0001:0002:0003:0004:0005:0006:0007', port=None, path='/some/path')"
-        assert repr(Location('ssh://user@[2a02:0001:0002:0003:0004:0005:0006:0007]:1234/some/path')) == \
-            "Location(proto='ssh', user='user', host='2a02:0001:0002:0003:0004:0005:0006:0007', port=1234, path='/some/path')"
+        monkeypatch.delenv("BORG_REPO", raising=False)
+        assert (
+            repr(Location("ssh://user@host:1234/some/path"))
+            == "Location(proto='ssh', user='user', host='host', port=1234, path='/some/path')"
+        )
+        assert Location("ssh://user@host:1234/some/path").to_key_filename() == keys_dir + "host__some_path"
+        assert (
+            repr(Location("ssh://user@host:1234/some/path"))
+            == "Location(proto='ssh', user='user', host='host', port=1234, path='/some/path')"
+        )
+        assert (
+            repr(Location("ssh://user@host/some/path"))
+            == "Location(proto='ssh', user='user', host='host', port=None, path='/some/path')"
+        )
+        assert (
+            repr(Location("ssh://user@[::]:1234/some/path"))
+            == "Location(proto='ssh', user='user', host='::', port=1234, path='/some/path')"
+        )
+        assert (
+            repr(Location("ssh://user@[::]:1234/some/path"))
+            == "Location(proto='ssh', user='user', host='::', port=1234, path='/some/path')"
+        )
+        assert Location("ssh://user@[::]:1234/some/path").to_key_filename() == keys_dir + "____some_path"
+        assert (
+            repr(Location("ssh://user@[::]/some/path"))
+            == "Location(proto='ssh', user='user', host='::', port=None, path='/some/path')"
+        )
+        assert (
+            repr(Location("ssh://user@[2001:db8::]:1234/some/path"))
+            == "Location(proto='ssh', user='user', host='2001:db8::', port=1234, path='/some/path')"
+        )
+        assert (
+            repr(Location("ssh://user@[2001:db8::]:1234/some/path"))
+            == "Location(proto='ssh', user='user', host='2001:db8::', port=1234, path='/some/path')"
+        )
+        assert (
+            Location("ssh://user@[2001:db8::]:1234/some/path").to_key_filename() == keys_dir + "2001_db8____some_path"
+        )
+        assert (
+            repr(Location("ssh://user@[2001:db8::]/some/path"))
+            == "Location(proto='ssh', user='user', host='2001:db8::', port=None, path='/some/path')"
+        )
+        assert (
+            repr(Location("ssh://user@[2001:db8::c0:ffee]:1234/some/path"))
+            == "Location(proto='ssh', user='user', host='2001:db8::c0:ffee', port=1234, path='/some/path')"
+        )
+        assert (
+            repr(Location("ssh://user@[2001:db8::c0:ffee]:1234/some/path"))
+            == "Location(proto='ssh', user='user', host='2001:db8::c0:ffee', port=1234, path='/some/path')"
+        )
+        assert (
+            repr(Location("ssh://user@[2001:db8::c0:ffee]/some/path"))
+            == "Location(proto='ssh', user='user', host='2001:db8::c0:ffee', port=None, path='/some/path')"
+        )
+        assert (
+            repr(Location("ssh://user@[2001:db8::192.0.2.1]:1234/some/path"))
+            == "Location(proto='ssh', user='user', host='2001:db8::192.0.2.1', port=1234, path='/some/path')"
+        )
+        assert (
+            repr(Location("ssh://user@[2001:db8::192.0.2.1]:1234/some/path"))
+            == "Location(proto='ssh', user='user', host='2001:db8::192.0.2.1', port=1234, path='/some/path')"
+        )
+        assert (
+            repr(Location("ssh://user@[2001:db8::192.0.2.1]/some/path"))
+            == "Location(proto='ssh', user='user', host='2001:db8::192.0.2.1', port=None, path='/some/path')"
+        )
+        assert (
+            Location("ssh://user@[2001:db8::192.0.2.1]/some/path").to_key_filename()
+            == keys_dir + "2001_db8__192_0_2_1__some_path"
+        )
+        assert (
+            repr(Location("ssh://user@[2a02:0001:0002:0003:0004:0005:0006:0007]/some/path"))
+            == "Location(proto='ssh', user='user', host='2a02:0001:0002:0003:0004:0005:0006:0007', port=None, path='/some/path')"
+        )
+        assert (
+            repr(Location("ssh://user@[2a02:0001:0002:0003:0004:0005:0006:0007]:1234/some/path"))
+            == "Location(proto='ssh', user='user', host='2a02:0001:0002:0003:0004:0005:0006:0007', port=1234, path='/some/path')"
+        )
 
     def test_file(self, monkeypatch, keys_dir):
-        monkeypatch.delenv('BORG_REPO', raising=False)
-        assert repr(Location('file:///some/path')) == \
-            "Location(proto='file', user=None, host=None, port=None, path='/some/path')"
-        assert repr(Location('file:///some/path')) == \
-            "Location(proto='file', user=None, host=None, port=None, path='/some/path')"
-        assert Location('file:///some/path').to_key_filename() == keys_dir + 'some_path'
+        monkeypatch.delenv("BORG_REPO", raising=False)
+        assert (
+            repr(Location("file:///some/path"))
+            == "Location(proto='file', user=None, host=None, port=None, path='/some/path')"
+        )
+        assert (
+            repr(Location("file:///some/path"))
+            == "Location(proto='file', user=None, host=None, port=None, path='/some/path')"
+        )
+        assert Location("file:///some/path").to_key_filename() == keys_dir + "some_path"
 
     def test_smb(self, monkeypatch, keys_dir):
-        monkeypatch.delenv('BORG_REPO', raising=False)
-        assert repr(Location('file:////server/share/path')) == \
-            "Location(proto='file', user=None, host=None, port=None, path='//server/share/path')"
-        assert Location('file:////server/share/path').to_key_filename() == keys_dir + 'server_share_path'
+        monkeypatch.delenv("BORG_REPO", raising=False)
+        assert (
+            repr(Location("file:////server/share/path"))
+            == "Location(proto='file', user=None, host=None, port=None, path='//server/share/path')"
+        )
+        assert Location("file:////server/share/path").to_key_filename() == keys_dir + "server_share_path"
 
     def test_folder(self, monkeypatch, keys_dir):
-        monkeypatch.delenv('BORG_REPO', raising=False)
-        assert repr(Location('path')) == \
-            "Location(proto='file', user=None, host=None, port=None, path='path')"
-        assert Location('path').to_key_filename() == keys_dir + 'path'
+        monkeypatch.delenv("BORG_REPO", raising=False)
+        assert repr(Location("path")) == "Location(proto='file', user=None, host=None, port=None, path='path')"
+        assert Location("path").to_key_filename() == keys_dir + "path"
 
     def test_long_path(self, monkeypatch, keys_dir):
-        monkeypatch.delenv('BORG_REPO', raising=False)
-        assert Location(os.path.join(*(40 * ['path']))).to_key_filename() == keys_dir + '_'.join(20 * ['path']) + '_'
+        monkeypatch.delenv("BORG_REPO", raising=False)
+        assert Location(os.path.join(*(40 * ["path"]))).to_key_filename() == keys_dir + "_".join(20 * ["path"]) + "_"
 
     def test_abspath(self, monkeypatch, keys_dir):
-        monkeypatch.delenv('BORG_REPO', raising=False)
-        assert repr(Location('/some/absolute/path')) == \
-            "Location(proto='file', user=None, host=None, port=None, path='/some/absolute/path')"
-        assert repr(Location('/some/absolute/path')) == \
-            "Location(proto='file', user=None, host=None, port=None, path='/some/absolute/path')"
-        assert Location('/some/absolute/path').to_key_filename() == keys_dir + 'some_absolute_path'
-        assert repr(Location('ssh://user@host/some/path')) == \
-               "Location(proto='ssh', user='user', host='host', port=None, path='/some/path')"
-        assert Location('ssh://user@host/some/path').to_key_filename() == keys_dir + 'host__some_path'
+        monkeypatch.delenv("BORG_REPO", raising=False)
+        assert (
+            repr(Location("/some/absolute/path"))
+            == "Location(proto='file', user=None, host=None, port=None, path='/some/absolute/path')"
+        )
+        assert (
+            repr(Location("/some/absolute/path"))
+            == "Location(proto='file', user=None, host=None, port=None, path='/some/absolute/path')"
+        )
+        assert Location("/some/absolute/path").to_key_filename() == keys_dir + "some_absolute_path"
+        assert (
+            repr(Location("ssh://user@host/some/path"))
+            == "Location(proto='ssh', user='user', host='host', port=None, path='/some/path')"
+        )
+        assert Location("ssh://user@host/some/path").to_key_filename() == keys_dir + "host__some_path"
 
     def test_relpath(self, monkeypatch, keys_dir):
-        monkeypatch.delenv('BORG_REPO', raising=False)
-        assert repr(Location('some/relative/path')) == \
-            "Location(proto='file', user=None, host=None, port=None, path='some/relative/path')"
-        assert repr(Location('some/relative/path')) == \
-            "Location(proto='file', user=None, host=None, port=None, path='some/relative/path')"
-        assert Location('some/relative/path').to_key_filename() == keys_dir + 'some_relative_path'
-        assert repr(Location('ssh://user@host/./some/path')) == \
-               "Location(proto='ssh', user='user', host='host', port=None, path='/./some/path')"
-        assert Location('ssh://user@host/./some/path').to_key_filename() == keys_dir + 'host__some_path'
-        assert repr(Location('ssh://user@host/~/some/path')) == \
-               "Location(proto='ssh', user='user', host='host', port=None, path='/~/some/path')"
-        assert Location('ssh://user@host/~/some/path').to_key_filename() == keys_dir + 'host__some_path'
-        assert repr(Location('ssh://user@host/~user/some/path')) == \
-               "Location(proto='ssh', user='user', host='host', port=None, path='/~user/some/path')"
-        assert Location('ssh://user@host/~user/some/path').to_key_filename() == keys_dir + 'host__user_some_path'
+        monkeypatch.delenv("BORG_REPO", raising=False)
+        assert (
+            repr(Location("some/relative/path"))
+            == "Location(proto='file', user=None, host=None, port=None, path='some/relative/path')"
+        )
+        assert (
+            repr(Location("some/relative/path"))
+            == "Location(proto='file', user=None, host=None, port=None, path='some/relative/path')"
+        )
+        assert Location("some/relative/path").to_key_filename() == keys_dir + "some_relative_path"
+        assert (
+            repr(Location("ssh://user@host/./some/path"))
+            == "Location(proto='ssh', user='user', host='host', port=None, path='/./some/path')"
+        )
+        assert Location("ssh://user@host/./some/path").to_key_filename() == keys_dir + "host__some_path"
+        assert (
+            repr(Location("ssh://user@host/~/some/path"))
+            == "Location(proto='ssh', user='user', host='host', port=None, path='/~/some/path')"
+        )
+        assert Location("ssh://user@host/~/some/path").to_key_filename() == keys_dir + "host__some_path"
+        assert (
+            repr(Location("ssh://user@host/~user/some/path"))
+            == "Location(proto='ssh', user='user', host='host', port=None, path='/~user/some/path')"
+        )
+        assert Location("ssh://user@host/~user/some/path").to_key_filename() == keys_dir + "host__user_some_path"
 
     def test_with_colons(self, monkeypatch, keys_dir):
-        monkeypatch.delenv('BORG_REPO', raising=False)
-        assert repr(Location('/abs/path:w:cols')) == \
-            "Location(proto='file', user=None, host=None, port=None, path='/abs/path:w:cols')"
-        assert repr(Location('/abs/path:with:colons')) == \
-            "Location(proto='file', user=None, host=None, port=None, path='/abs/path:with:colons')"
-        assert repr(Location('/abs/path:with:colons')) == \
-            "Location(proto='file', user=None, host=None, port=None, path='/abs/path:with:colons')"
-        assert Location('/abs/path:with:colons').to_key_filename() == keys_dir + 'abs_path_with_colons'
+        monkeypatch.delenv("BORG_REPO", raising=False)
+        assert (
+            repr(Location("/abs/path:w:cols"))
+            == "Location(proto='file', user=None, host=None, port=None, path='/abs/path:w:cols')"
+        )
+        assert (
+            repr(Location("/abs/path:with:colons"))
+            == "Location(proto='file', user=None, host=None, port=None, path='/abs/path:with:colons')"
+        )
+        assert (
+            repr(Location("/abs/path:with:colons"))
+            == "Location(proto='file', user=None, host=None, port=None, path='/abs/path:with:colons')"
+        )
+        assert Location("/abs/path:with:colons").to_key_filename() == keys_dir + "abs_path_with_colons"
 
     def test_canonical_path(self, monkeypatch):
-        monkeypatch.delenv('BORG_REPO', raising=False)
-        locations = ['some/path', 'file://some/path', 'host:some/path',
-                     'host:~user/some/path', 'ssh://host/some/path',
-                     'ssh://user@host:1234/some/path']
+        monkeypatch.delenv("BORG_REPO", raising=False)
+        locations = [
+            "some/path",
+            "file://some/path",
+            "host:some/path",
+            "host:~user/some/path",
+            "ssh://host/some/path",
+            "ssh://user@host:1234/some/path",
+        ]
         for location in locations:
-            assert Location(location).canonical_path() == \
-                Location(Location(location).canonical_path()).canonical_path(), "failed: %s" % location
+            assert (
+                Location(location).canonical_path() == Location(Location(location).canonical_path()).canonical_path()
+            ), ("failed: %s" % location)
 
     def test_bad_syntax(self):
         with pytest.raises(ValueError):
             # this is invalid due to the 2nd colon, correct: 'ssh://user@host/path'
-            Location('ssh://user@host:/path')
+            Location("ssh://user@host:/path")
 
 
 class FormatTimedeltaTestCase(BaseTestCase):
-
     def test(self):
         t0 = datetime(2001, 1, 1, 10, 20, 3, 0)
         t1 = datetime(2001, 1, 1, 12, 20, 4, 100000)
-        self.assert_equal(
-            format_timedelta(t1 - t0),
-            '2 hours 1.10 seconds'
-        )
+        self.assert_equal(format_timedelta(t1 - t0), "2 hours 1.10 seconds")
 
 
 def test_chunkerparams():
-    assert ChunkerParams('default') == ('buzhash', 19, 23, 21, 4095)
-    assert ChunkerParams('19,23,21,4095') == ('buzhash', 19, 23, 21, 4095)
-    assert ChunkerParams('buzhash,19,23,21,4095') == ('buzhash', 19, 23, 21, 4095)
-    assert ChunkerParams('10,23,16,4095') == ('buzhash', 10, 23, 16, 4095)
-    assert ChunkerParams('fixed,4096') == ('fixed', 4096, 0)
-    assert ChunkerParams('fixed,4096,200') == ('fixed', 4096, 200)
+    assert ChunkerParams("default") == ("buzhash", 19, 23, 21, 4095)
+    assert ChunkerParams("19,23,21,4095") == ("buzhash", 19, 23, 21, 4095)
+    assert ChunkerParams("buzhash,19,23,21,4095") == ("buzhash", 19, 23, 21, 4095)
+    assert ChunkerParams("10,23,16,4095") == ("buzhash", 10, 23, 16, 4095)
+    assert ChunkerParams("fixed,4096") == ("fixed", 4096, 0)
+    assert ChunkerParams("fixed,4096,200") == ("fixed", 4096, 200)
     # invalid values checking
     with pytest.raises(ValueError):
-        ChunkerParams('crap,1,2,3,4')  # invalid algo
+        ChunkerParams("crap,1,2,3,4")  # invalid algo
     with pytest.raises(ValueError):
-        ChunkerParams('buzhash,5,7,6,4095')  # too small min. size
+        ChunkerParams("buzhash,5,7,6,4095")  # too small min. size
     with pytest.raises(ValueError):
-        ChunkerParams('buzhash,19,24,21,4095')  # too big max. size
+        ChunkerParams("buzhash,19,24,21,4095")  # too big max. size
     with pytest.raises(ValueError):
-        ChunkerParams('buzhash,23,19,21,4095')  # violates min <= mask <= max
+        ChunkerParams("buzhash,23,19,21,4095")  # violates min <= mask <= max
     with pytest.raises(ValueError):
-        ChunkerParams('fixed,63')  # too small block size
+        ChunkerParams("fixed,63")  # too small block size
     with pytest.raises(ValueError):
-        ChunkerParams('fixed,%d,%d' % (MAX_DATA_SIZE + 1, 4096))  # too big block size
+        ChunkerParams("fixed,%d,%d" % (MAX_DATA_SIZE + 1, 4096))  # too big block size
     with pytest.raises(ValueError):
-        ChunkerParams('fixed,%d,%d' % (4096, MAX_DATA_SIZE + 1))  # too big header size
+        ChunkerParams("fixed,%d,%d" % (4096, MAX_DATA_SIZE + 1))  # too big header size
 
 
 class MakePathSafeTestCase(BaseTestCase):
-
     def test(self):
-        self.assert_equal(make_path_safe('/foo/bar'), 'foo/bar')
-        self.assert_equal(make_path_safe('/foo/bar'), 'foo/bar')
-        self.assert_equal(make_path_safe('/f/bar'), 'f/bar')
-        self.assert_equal(make_path_safe('fo/bar'), 'fo/bar')
-        self.assert_equal(make_path_safe('../foo/bar'), 'foo/bar')
-        self.assert_equal(make_path_safe('../../foo/bar'), 'foo/bar')
-        self.assert_equal(make_path_safe('/'), '.')
-        self.assert_equal(make_path_safe('/'), '.')
+        self.assert_equal(make_path_safe("/foo/bar"), "foo/bar")
+        self.assert_equal(make_path_safe("/foo/bar"), "foo/bar")
+        self.assert_equal(make_path_safe("/f/bar"), "f/bar")
+        self.assert_equal(make_path_safe("fo/bar"), "fo/bar")
+        self.assert_equal(make_path_safe("../foo/bar"), "foo/bar")
+        self.assert_equal(make_path_safe("../../foo/bar"), "foo/bar")
+        self.assert_equal(make_path_safe("/"), ".")
+        self.assert_equal(make_path_safe("/"), ".")
 
 
 class MockArchive:
-
     def __init__(self, ts, id):
         self.ts = ts
         self.id = id
@@ -228,7 +302,8 @@ class MockArchive:
 
 
 @pytest.mark.parametrize(
-    "rule,num_to_keep,expected_ids", [
+    "rule,num_to_keep,expected_ids",
+    [
         ("yearly", 3, (13, 2, 1)),
         ("monthly", 3, (13, 8, 4)),
         ("weekly", 2, (13, 8)),
@@ -237,7 +312,7 @@ class MockArchive:
         ("minutely", 3, (13, 10, 9)),
         ("secondly", 4, (13, 12, 11, 10)),
         ("daily", 0, []),
-    ]
+    ],
 )
 def test_prune_split(rule, num_to_keep, expected_ids):
     def subset(lst, ids):
@@ -318,40 +393,33 @@ def test_prune_split_no_archives():
 
 class IntervalTestCase(BaseTestCase):
     def test_interval(self):
-        self.assert_equal(interval('1H'), 1)
-        self.assert_equal(interval('1d'), 24)
-        self.assert_equal(interval('1w'), 168)
-        self.assert_equal(interval('1m'), 744)
-        self.assert_equal(interval('1y'), 8760)
+        self.assert_equal(interval("1H"), 1)
+        self.assert_equal(interval("1d"), 24)
+        self.assert_equal(interval("1w"), 168)
+        self.assert_equal(interval("1m"), 744)
+        self.assert_equal(interval("1y"), 8760)
 
     def test_interval_time_unit(self):
         with pytest.raises(ArgumentTypeError) as exc:
-            interval('H')
-        self.assert_equal(
-            exc.value.args,
-            ('Unexpected interval number "": expected an integer greater than 0',))
+            interval("H")
+        self.assert_equal(exc.value.args, ('Unexpected interval number "": expected an integer greater than 0',))
         with pytest.raises(ArgumentTypeError) as exc:
-            interval('-1d')
-        self.assert_equal(
-            exc.value.args,
-            ('Unexpected interval number "-1": expected an integer greater than 0',))
+            interval("-1d")
+        self.assert_equal(exc.value.args, ('Unexpected interval number "-1": expected an integer greater than 0',))
         with pytest.raises(ArgumentTypeError) as exc:
-            interval('food')
-        self.assert_equal(
-            exc.value.args,
-            ('Unexpected interval number "foo": expected an integer greater than 0',))
+            interval("food")
+        self.assert_equal(exc.value.args, ('Unexpected interval number "foo": expected an integer greater than 0',))
 
     def test_interval_number(self):
         with pytest.raises(ArgumentTypeError) as exc:
-            interval('5')
+            interval("5")
         self.assert_equal(
-            exc.value.args,
-            ("Unexpected interval time unit \"5\": expected one of ['H', 'd', 'w', 'm', 'y']",))
+            exc.value.args, ("Unexpected interval time unit \"5\": expected one of ['H', 'd', 'w', 'm', 'y']",)
+        )
 
 
 class PruneWithinTestCase(BaseTestCase):
     def test_prune_within(self):
-
         def subset(lst, indices):
             return {lst[i] for i in indices}
 
@@ -359,129 +427,128 @@ class PruneWithinTestCase(BaseTestCase):
             for ta in test_archives, reversed(test_archives):
                 kept_because = {}
                 keep = prune_within(ta, interval(within), kept_because)
-                self.assert_equal(set(keep),
-                                  subset(test_archives, indices))
+                self.assert_equal(set(keep), subset(test_archives, indices))
                 assert all("within" == kept_because[a.id][0] for a in keep)
 
         # 1 minute, 1.5 hours, 2.5 hours, 3.5 hours, 25 hours, 49 hours
-        test_offsets = [60, 90*60, 150*60, 210*60, 25*60*60, 49*60*60]
+        test_offsets = [60, 90 * 60, 150 * 60, 210 * 60, 25 * 60 * 60, 49 * 60 * 60]
         now = datetime.now(timezone.utc)
         test_dates = [now - timedelta(seconds=s) for s in test_offsets]
-        test_archives = [
-            MockArchive(date, i) for i, date in enumerate(test_dates)
-        ]
+        test_archives = [MockArchive(date, i) for i, date in enumerate(test_dates)]
 
-        dotest(test_archives, '1H', [0])
-        dotest(test_archives, '2H', [0, 1])
-        dotest(test_archives, '3H', [0, 1, 2])
-        dotest(test_archives, '24H', [0, 1, 2, 3])
-        dotest(test_archives, '26H', [0, 1, 2, 3, 4])
-        dotest(test_archives, '2d', [0, 1, 2, 3, 4])
-        dotest(test_archives, '50H', [0, 1, 2, 3, 4, 5])
-        dotest(test_archives, '3d', [0, 1, 2, 3, 4, 5])
-        dotest(test_archives, '1w', [0, 1, 2, 3, 4, 5])
-        dotest(test_archives, '1m', [0, 1, 2, 3, 4, 5])
-        dotest(test_archives, '1y', [0, 1, 2, 3, 4, 5])
+        dotest(test_archives, "1H", [0])
+        dotest(test_archives, "2H", [0, 1])
+        dotest(test_archives, "3H", [0, 1, 2])
+        dotest(test_archives, "24H", [0, 1, 2, 3])
+        dotest(test_archives, "26H", [0, 1, 2, 3, 4])
+        dotest(test_archives, "2d", [0, 1, 2, 3, 4])
+        dotest(test_archives, "50H", [0, 1, 2, 3, 4, 5])
+        dotest(test_archives, "3d", [0, 1, 2, 3, 4, 5])
+        dotest(test_archives, "1w", [0, 1, 2, 3, 4, 5])
+        dotest(test_archives, "1m", [0, 1, 2, 3, 4, 5])
+        dotest(test_archives, "1y", [0, 1, 2, 3, 4, 5])
 
 
 class StableDictTestCase(BaseTestCase):
-
     def test(self):
         d = StableDict(foo=1, bar=2, boo=3, baz=4)
-        self.assert_equal(list(d.items()), [('bar', 2), ('baz', 4), ('boo', 3), ('foo', 1)])
-        self.assert_equal(hashlib.md5(msgpack.packb(d)).hexdigest(), 'fc78df42cd60691b3ac3dd2a2b39903f')
+        self.assert_equal(list(d.items()), [("bar", 2), ("baz", 4), ("boo", 3), ("foo", 1)])
+        self.assert_equal(hashlib.md5(msgpack.packb(d)).hexdigest(), "fc78df42cd60691b3ac3dd2a2b39903f")
 
 
 class TestParseTimestamp(BaseTestCase):
-
     def test(self):
-        self.assert_equal(parse_timestamp('2015-04-19T20:25:00.226410'), datetime(2015, 4, 19, 20, 25, 0, 226410, timezone.utc))
-        self.assert_equal(parse_timestamp('2015-04-19T20:25:00'), datetime(2015, 4, 19, 20, 25, 0, 0, timezone.utc))
+        self.assert_equal(
+            parse_timestamp("2015-04-19T20:25:00.226410"), datetime(2015, 4, 19, 20, 25, 0, 226410, timezone.utc)
+        )
+        self.assert_equal(parse_timestamp("2015-04-19T20:25:00"), datetime(2015, 4, 19, 20, 25, 0, 0, timezone.utc))
 
 
 def test_get_base_dir(monkeypatch):
     """test that get_base_dir respects environment"""
-    monkeypatch.delenv('BORG_BASE_DIR', raising=False)
-    monkeypatch.delenv('HOME', raising=False)
-    monkeypatch.delenv('USER', raising=False)
-    assert get_base_dir() == os.path.expanduser('~')
-    monkeypatch.setenv('USER', 'root')
-    assert get_base_dir() == os.path.expanduser('~root')
-    monkeypatch.setenv('HOME', '/var/tmp/home')
-    assert get_base_dir() == '/var/tmp/home'
-    monkeypatch.setenv('BORG_BASE_DIR', '/var/tmp/base')
-    assert get_base_dir() == '/var/tmp/base'
+    monkeypatch.delenv("BORG_BASE_DIR", raising=False)
+    monkeypatch.delenv("HOME", raising=False)
+    monkeypatch.delenv("USER", raising=False)
+    assert get_base_dir() == os.path.expanduser("~")
+    monkeypatch.setenv("USER", "root")
+    assert get_base_dir() == os.path.expanduser("~root")
+    monkeypatch.setenv("HOME", "/var/tmp/home")
+    assert get_base_dir() == "/var/tmp/home"
+    monkeypatch.setenv("BORG_BASE_DIR", "/var/tmp/base")
+    assert get_base_dir() == "/var/tmp/base"
 
 
 def test_get_config_dir(monkeypatch):
     """test that get_config_dir respects environment"""
-    monkeypatch.delenv('BORG_CONFIG_DIR', raising=False)
-    monkeypatch.delenv('XDG_CONFIG_HOME', raising=False)
-    assert get_config_dir() == os.path.join(os.path.expanduser('~'), '.config', 'borg')
-    monkeypatch.setenv('XDG_CONFIG_HOME', '/var/tmp/.config')
-    assert get_config_dir() == os.path.join('/var/tmp/.config', 'borg')
-    monkeypatch.setenv('BORG_CONFIG_DIR', '/var/tmp')
-    assert get_config_dir() == '/var/tmp'
+    monkeypatch.delenv("BORG_CONFIG_DIR", raising=False)
+    monkeypatch.delenv("XDG_CONFIG_HOME", raising=False)
+    assert get_config_dir() == os.path.join(os.path.expanduser("~"), ".config", "borg")
+    monkeypatch.setenv("XDG_CONFIG_HOME", "/var/tmp/.config")
+    assert get_config_dir() == os.path.join("/var/tmp/.config", "borg")
+    monkeypatch.setenv("BORG_CONFIG_DIR", "/var/tmp")
+    assert get_config_dir() == "/var/tmp"
 
 
 def test_get_cache_dir(monkeypatch):
     """test that get_cache_dir respects environment"""
-    monkeypatch.delenv('BORG_CACHE_DIR', raising=False)
-    monkeypatch.delenv('XDG_CACHE_HOME', raising=False)
-    assert get_cache_dir() == os.path.join(os.path.expanduser('~'), '.cache', 'borg')
-    monkeypatch.setenv('XDG_CACHE_HOME', '/var/tmp/.cache')
-    assert get_cache_dir() == os.path.join('/var/tmp/.cache', 'borg')
-    monkeypatch.setenv('BORG_CACHE_DIR', '/var/tmp')
-    assert get_cache_dir() == '/var/tmp'
+    monkeypatch.delenv("BORG_CACHE_DIR", raising=False)
+    monkeypatch.delenv("XDG_CACHE_HOME", raising=False)
+    assert get_cache_dir() == os.path.join(os.path.expanduser("~"), ".cache", "borg")
+    monkeypatch.setenv("XDG_CACHE_HOME", "/var/tmp/.cache")
+    assert get_cache_dir() == os.path.join("/var/tmp/.cache", "borg")
+    monkeypatch.setenv("BORG_CACHE_DIR", "/var/tmp")
+    assert get_cache_dir() == "/var/tmp"
 
 
 def test_get_keys_dir(monkeypatch):
     """test that get_keys_dir respects environment"""
-    monkeypatch.delenv('BORG_KEYS_DIR', raising=False)
-    monkeypatch.delenv('XDG_CONFIG_HOME', raising=False)
-    assert get_keys_dir() == os.path.join(os.path.expanduser('~'), '.config', 'borg', 'keys')
-    monkeypatch.setenv('XDG_CONFIG_HOME', '/var/tmp/.config')
-    assert get_keys_dir() == os.path.join('/var/tmp/.config', 'borg', 'keys')
-    monkeypatch.setenv('BORG_KEYS_DIR', '/var/tmp')
-    assert get_keys_dir() == '/var/tmp'
+    monkeypatch.delenv("BORG_KEYS_DIR", raising=False)
+    monkeypatch.delenv("XDG_CONFIG_HOME", raising=False)
+    assert get_keys_dir() == os.path.join(os.path.expanduser("~"), ".config", "borg", "keys")
+    monkeypatch.setenv("XDG_CONFIG_HOME", "/var/tmp/.config")
+    assert get_keys_dir() == os.path.join("/var/tmp/.config", "borg", "keys")
+    monkeypatch.setenv("BORG_KEYS_DIR", "/var/tmp")
+    assert get_keys_dir() == "/var/tmp"
 
 
 def test_get_security_dir(monkeypatch):
     """test that get_security_dir respects environment"""
-    monkeypatch.delenv('BORG_SECURITY_DIR', raising=False)
-    monkeypatch.delenv('XDG_CONFIG_HOME', raising=False)
-    assert get_security_dir() == os.path.join(os.path.expanduser('~'), '.config', 'borg', 'security')
-    assert get_security_dir(repository_id='1234') == os.path.join(os.path.expanduser('~'), '.config', 'borg', 'security', '1234')
-    monkeypatch.setenv('XDG_CONFIG_HOME', '/var/tmp/.config')
-    assert get_security_dir() == os.path.join('/var/tmp/.config', 'borg', 'security')
-    monkeypatch.setenv('BORG_SECURITY_DIR', '/var/tmp')
-    assert get_security_dir() == '/var/tmp'
+    monkeypatch.delenv("BORG_SECURITY_DIR", raising=False)
+    monkeypatch.delenv("XDG_CONFIG_HOME", raising=False)
+    assert get_security_dir() == os.path.join(os.path.expanduser("~"), ".config", "borg", "security")
+    assert get_security_dir(repository_id="1234") == os.path.join(
+        os.path.expanduser("~"), ".config", "borg", "security", "1234"
+    )
+    monkeypatch.setenv("XDG_CONFIG_HOME", "/var/tmp/.config")
+    assert get_security_dir() == os.path.join("/var/tmp/.config", "borg", "security")
+    monkeypatch.setenv("BORG_SECURITY_DIR", "/var/tmp")
+    assert get_security_dir() == "/var/tmp"
 
 
 def test_file_size():
     """test the size formatting routines"""
     si_size_map = {
-        0: '0 B',  # no rounding necessary for those
-        1: '1 B',
-        142: '142 B',
-        999: '999 B',
-        1000: '1.00 kB',  # rounding starts here
-        1001: '1.00 kB',  # should be rounded away
-        1234: '1.23 kB',  # should be rounded down
-        1235: '1.24 kB',  # should be rounded up
-        1010: '1.01 kB',  # rounded down as well
-        999990000: '999.99 MB',  # rounded down
-        999990001: '999.99 MB',  # rounded down
-        999995000: '1.00 GB',  # rounded up to next unit
-        10**6: '1.00 MB',  # and all the remaining units, megabytes
-        10**9: '1.00 GB',  # gigabytes
-        10**12: '1.00 TB',  # terabytes
-        10**15: '1.00 PB',  # petabytes
-        10**18: '1.00 EB',  # exabytes
-        10**21: '1.00 ZB',  # zottabytes
-        10**24: '1.00 YB',  # yottabytes
-        -1: '-1 B',  # negative value
-        -1010: '-1.01 kB',  # negative value with rounding
+        0: "0 B",  # no rounding necessary for those
+        1: "1 B",
+        142: "142 B",
+        999: "999 B",
+        1000: "1.00 kB",  # rounding starts here
+        1001: "1.00 kB",  # should be rounded away
+        1234: "1.23 kB",  # should be rounded down
+        1235: "1.24 kB",  # should be rounded up
+        1010: "1.01 kB",  # rounded down as well
+        999990000: "999.99 MB",  # rounded down
+        999990001: "999.99 MB",  # rounded down
+        999995000: "1.00 GB",  # rounded up to next unit
+        10**6: "1.00 MB",  # and all the remaining units, megabytes
+        10**9: "1.00 GB",  # gigabytes
+        10**12: "1.00 TB",  # terabytes
+        10**15: "1.00 PB",  # petabytes
+        10**18: "1.00 EB",  # exabytes
+        10**21: "1.00 ZB",  # zottabytes
+        10**24: "1.00 YB",  # yottabytes
+        -1: "-1 B",  # negative value
+        -1010: "-1.01 kB",  # negative value with rounding
     }
     for size, fmt in si_size_map.items():
         assert format_file_size(size) == fmt
@@ -490,57 +557,44 @@ def test_file_size():
 def test_file_size_iec():
     """test the size formatting routines"""
     iec_size_map = {
-        0: '0 B',
-        2**0: '1 B',
-        2**10: '1.00 KiB',
-        2**20: '1.00 MiB',
-        2**30: '1.00 GiB',
-        2**40: '1.00 TiB',
-        2**50: '1.00 PiB',
-        2**60: '1.00 EiB',
-        2**70: '1.00 ZiB',
-        2**80: '1.00 YiB',
-        -2**0: '-1 B',
-        -2**10: '-1.00 KiB',
-        -2**20: '-1.00 MiB',
+        0: "0 B",
+        2**0: "1 B",
+        2**10: "1.00 KiB",
+        2**20: "1.00 MiB",
+        2**30: "1.00 GiB",
+        2**40: "1.00 TiB",
+        2**50: "1.00 PiB",
+        2**60: "1.00 EiB",
+        2**70: "1.00 ZiB",
+        2**80: "1.00 YiB",
+        -(2**0): "-1 B",
+        -(2**10): "-1.00 KiB",
+        -(2**20): "-1.00 MiB",
     }
     for size, fmt in iec_size_map.items():
         assert format_file_size(size, iec=True) == fmt
 
 
 def test_file_size_precision():
-    assert format_file_size(1234, precision=1) == '1.2 kB'  # rounded down
-    assert format_file_size(1254, precision=1) == '1.3 kB'  # rounded up
-    assert format_file_size(999990000, precision=1) == '1.0 GB'  # and not 999.9 MB or 1000.0 MB
+    assert format_file_size(1234, precision=1) == "1.2 kB"  # rounded down
+    assert format_file_size(1254, precision=1) == "1.3 kB"  # rounded up
+    assert format_file_size(999990000, precision=1) == "1.0 GB"  # and not 999.9 MB or 1000.0 MB
 
 
 def test_file_size_sign():
-    si_size_map = {
-        0: '0 B',
-        1: '+1 B',
-        1234: '+1.23 kB',
-        -1: '-1 B',
-        -1234: '-1.23 kB',
-    }
+    si_size_map = {0: "0 B", 1: "+1 B", 1234: "+1.23 kB", -1: "-1 B", -1234: "-1.23 kB"}
     for size, fmt in si_size_map.items():
         assert format_file_size(size, sign=True) == fmt
 
 
-@pytest.mark.parametrize('string,value', (
-    ('1', 1),
-    ('20', 20),
-    ('5K', 5000),
-    ('1.75M', 1750000),
-    ('1e+9', 1e9),
-    ('-1T', -1e12),
-))
+@pytest.mark.parametrize(
+    "string,value", (("1", 1), ("20", 20), ("5K", 5000), ("1.75M", 1750000), ("1e+9", 1e9), ("-1T", -1e12))
+)
 def test_parse_file_size(string, value):
     assert parse_file_size(string) == int(value)
 
 
-@pytest.mark.parametrize('string', (
-    '', '5 Äpfel', '4E', '2229 bit', '1B',
-))
+@pytest.mark.parametrize("string", ("", "5 Äpfel", "4E", "2229 bit", "1B"))
 def test_parse_file_size_invalid(string):
     with pytest.raises(ValueError):
         parse_file_size(string)
@@ -550,6 +604,7 @@ def test_is_slow_msgpack():
     # we need to import upstream msgpack package here, not helpers.msgpack:
     import msgpack
     import msgpack.fallback
+
     saved_packer = msgpack.Packer
     try:
         msgpack.Packer = msgpack.fallback.Packer
@@ -637,34 +692,34 @@ def test_yes_input_defaults():
 
 
 def test_yes_input_custom():
-    input = FakeInputs(['YES', 'SURE', 'NOPE', ])
-    assert yes(truish=('YES', ), input=input)
-    assert yes(truish=('SURE', ), input=input)
-    assert not yes(falsish=('NOPE', ), input=input)
+    input = FakeInputs(["YES", "SURE", "NOPE"])
+    assert yes(truish=("YES",), input=input)
+    assert yes(truish=("SURE",), input=input)
+    assert not yes(falsish=("NOPE",), input=input)
 
 
 def test_yes_env(monkeypatch):
     for value in TRUISH:
-        monkeypatch.setenv('OVERRIDE_THIS', value)
-        assert yes(env_var_override='OVERRIDE_THIS')
+        monkeypatch.setenv("OVERRIDE_THIS", value)
+        assert yes(env_var_override="OVERRIDE_THIS")
     for value in FALSISH:
-        monkeypatch.setenv('OVERRIDE_THIS', value)
-        assert not yes(env_var_override='OVERRIDE_THIS')
+        monkeypatch.setenv("OVERRIDE_THIS", value)
+        assert not yes(env_var_override="OVERRIDE_THIS")
 
 
 def test_yes_env_default(monkeypatch):
     for value in DEFAULTISH:
-        monkeypatch.setenv('OVERRIDE_THIS', value)
-        assert yes(env_var_override='OVERRIDE_THIS', default=True)
-        assert not yes(env_var_override='OVERRIDE_THIS', default=False)
+        monkeypatch.setenv("OVERRIDE_THIS", value)
+        assert yes(env_var_override="OVERRIDE_THIS", default=True)
+        assert not yes(env_var_override="OVERRIDE_THIS", default=False)
 
 
 def test_yes_defaults():
-    input = FakeInputs(['invalid', '', ' '])
+    input = FakeInputs(["invalid", "", " "])
     assert not yes(input=input)  # default=False
     assert not yes(input=input)
     assert not yes(input=input)
-    input = FakeInputs(['invalid', '', ' '])
+    input = FakeInputs(["invalid", "", " "])
     assert yes(default=True, input=input)
     assert yes(default=True, input=input)
     assert yes(default=True, input=input)
@@ -676,159 +731,159 @@ def test_yes_defaults():
 
 
 def test_yes_retry():
-    input = FakeInputs(['foo', 'bar', TRUISH[0], ])
-    assert yes(retry_msg='Retry: ', input=input)
-    input = FakeInputs(['foo', 'bar', FALSISH[0], ])
-    assert not yes(retry_msg='Retry: ', input=input)
+    input = FakeInputs(["foo", "bar", TRUISH[0]])
+    assert yes(retry_msg="Retry: ", input=input)
+    input = FakeInputs(["foo", "bar", FALSISH[0]])
+    assert not yes(retry_msg="Retry: ", input=input)
 
 
 def test_yes_no_retry():
-    input = FakeInputs(['foo', 'bar', TRUISH[0], ])
+    input = FakeInputs(["foo", "bar", TRUISH[0]])
     assert not yes(retry=False, default=False, input=input)
-    input = FakeInputs(['foo', 'bar', FALSISH[0], ])
+    input = FakeInputs(["foo", "bar", FALSISH[0]])
     assert yes(retry=False, default=True, input=input)
 
 
 def test_yes_output(capfd):
-    input = FakeInputs(['invalid', 'y', 'n'])
-    assert yes(msg='intro-msg', false_msg='false-msg', true_msg='true-msg', retry_msg='retry-msg', input=input)
+    input = FakeInputs(["invalid", "y", "n"])
+    assert yes(msg="intro-msg", false_msg="false-msg", true_msg="true-msg", retry_msg="retry-msg", input=input)
     out, err = capfd.readouterr()
-    assert out == ''
-    assert 'intro-msg' in err
-    assert 'retry-msg' in err
-    assert 'true-msg' in err
-    assert not yes(msg='intro-msg', false_msg='false-msg', true_msg='true-msg', retry_msg='retry-msg', input=input)
+    assert out == ""
+    assert "intro-msg" in err
+    assert "retry-msg" in err
+    assert "true-msg" in err
+    assert not yes(msg="intro-msg", false_msg="false-msg", true_msg="true-msg", retry_msg="retry-msg", input=input)
     out, err = capfd.readouterr()
-    assert out == ''
-    assert 'intro-msg' in err
-    assert 'retry-msg' not in err
-    assert 'false-msg' in err
+    assert out == ""
+    assert "intro-msg" in err
+    assert "retry-msg" not in err
+    assert "false-msg" in err
 
 
 def test_yes_env_output(capfd, monkeypatch):
-    env_var = 'OVERRIDE_SOMETHING'
-    monkeypatch.setenv(env_var, 'yes')
+    env_var = "OVERRIDE_SOMETHING"
+    monkeypatch.setenv(env_var, "yes")
     assert yes(env_var_override=env_var)
     out, err = capfd.readouterr()
-    assert out == ''
+    assert out == ""
     assert env_var in err
-    assert 'yes' in err
+    assert "yes" in err
 
 
 def test_progress_percentage_sameline(capfd, monkeypatch):
     # run the test as if it was in a 4x1 terminal
-    monkeypatch.setenv('COLUMNS', '4')
-    monkeypatch.setenv('LINES', '1')
+    monkeypatch.setenv("COLUMNS", "4")
+    monkeypatch.setenv("LINES", "1")
     pi = ProgressIndicatorPercent(1000, step=5, start=0, msg="%3.0f%%")
-    pi.logger.setLevel('INFO')
+    pi.logger.setLevel("INFO")
     pi.show(0)
     out, err = capfd.readouterr()
-    assert err == '  0%\r'
+    assert err == "  0%\r"
     pi.show(420)
     pi.show(680)
     out, err = capfd.readouterr()
-    assert err == ' 42%\r 68%\r'
+    assert err == " 42%\r 68%\r"
     pi.show(1000)
     out, err = capfd.readouterr()
-    assert err == '100%\r'
+    assert err == "100%\r"
     pi.finish()
     out, err = capfd.readouterr()
-    assert err == ' ' * 4 + '\r'
+    assert err == " " * 4 + "\r"
 
 
 def test_progress_percentage_step(capfd, monkeypatch):
     # run the test as if it was in a 4x1 terminal
-    monkeypatch.setenv('COLUMNS', '4')
-    monkeypatch.setenv('LINES', '1')
+    monkeypatch.setenv("COLUMNS", "4")
+    monkeypatch.setenv("LINES", "1")
     pi = ProgressIndicatorPercent(100, step=2, start=0, msg="%3.0f%%")
-    pi.logger.setLevel('INFO')
+    pi.logger.setLevel("INFO")
     pi.show()
     out, err = capfd.readouterr()
-    assert err == '  0%\r'
+    assert err == "  0%\r"
     pi.show()
     out, err = capfd.readouterr()
-    assert err == ''  # no output at 1% as we have step == 2
+    assert err == ""  # no output at 1% as we have step == 2
     pi.show()
     out, err = capfd.readouterr()
-    assert err == '  2%\r'
+    assert err == "  2%\r"
 
 
 def test_progress_percentage_quiet(capfd):
     pi = ProgressIndicatorPercent(1000, step=5, start=0, msg="%3.0f%%")
-    pi.logger.setLevel('WARN')
+    pi.logger.setLevel("WARN")
     pi.show(0)
     out, err = capfd.readouterr()
-    assert err == ''
+    assert err == ""
     pi.show(1000)
     out, err = capfd.readouterr()
-    assert err == ''
+    assert err == ""
     pi.finish()
     out, err = capfd.readouterr()
-    assert err == ''
+    assert err == ""
 
 
 def test_progress_endless(capfd):
     pi = ProgressIndicatorEndless(step=1, file=sys.stderr)
     pi.show()
     out, err = capfd.readouterr()
-    assert err == '.'
+    assert err == "."
     pi.show()
     out, err = capfd.readouterr()
-    assert err == '.'
+    assert err == "."
     pi.finish()
     out, err = capfd.readouterr()
-    assert err == '\n'
+    assert err == "\n"
 
 
 def test_progress_endless_step(capfd):
     pi = ProgressIndicatorEndless(step=2, file=sys.stderr)
     pi.show()
     out, err = capfd.readouterr()
-    assert err == ''  # no output here as we have step == 2
+    assert err == ""  # no output here as we have step == 2
     pi.show()
     out, err = capfd.readouterr()
-    assert err == '.'
+    assert err == "."
     pi.show()
     out, err = capfd.readouterr()
-    assert err == ''  # no output here as we have step == 2
+    assert err == ""  # no output here as we have step == 2
     pi.show()
     out, err = capfd.readouterr()
-    assert err == '.'
+    assert err == "."
 
 
 def test_partial_format():
-    assert partial_format('{space:10}', {'space': ' '}) == ' ' * 10
-    assert partial_format('{foobar}', {'bar': 'wrong', 'foobar': 'correct'}) == 'correct'
-    assert partial_format('{unknown_key}', {}) == '{unknown_key}'
-    assert partial_format('{key}{{escaped_key}}', {}) == '{key}{{escaped_key}}'
-    assert partial_format('{{escaped_key}}', {'escaped_key': 1234}) == '{{escaped_key}}'
+    assert partial_format("{space:10}", {"space": " "}) == " " * 10
+    assert partial_format("{foobar}", {"bar": "wrong", "foobar": "correct"}) == "correct"
+    assert partial_format("{unknown_key}", {}) == "{unknown_key}"
+    assert partial_format("{key}{{escaped_key}}", {}) == "{key}{{escaped_key}}"
+    assert partial_format("{{escaped_key}}", {"escaped_key": 1234}) == "{{escaped_key}}"
 
 
 def test_chunk_file_wrapper():
-    cfw = ChunkIteratorFileWrapper(iter([b'abc', b'def']))
-    assert cfw.read(2) == b'ab'
-    assert cfw.read(50) == b'cdef'
+    cfw = ChunkIteratorFileWrapper(iter([b"abc", b"def"]))
+    assert cfw.read(2) == b"ab"
+    assert cfw.read(50) == b"cdef"
     assert cfw.exhausted
 
     cfw = ChunkIteratorFileWrapper(iter([]))
-    assert cfw.read(2) == b''
+    assert cfw.read(2) == b""
     assert cfw.exhausted
 
 
 def test_chunkit():
-    it = chunkit('abcdefg', 3)
-    assert next(it) == ['a', 'b', 'c']
-    assert next(it) == ['d', 'e', 'f']
-    assert next(it) == ['g']
+    it = chunkit("abcdefg", 3)
+    assert next(it) == ["a", "b", "c"]
+    assert next(it) == ["d", "e", "f"]
+    assert next(it) == ["g"]
     with pytest.raises(StopIteration):
         next(it)
     with pytest.raises(StopIteration):
         next(it)
 
-    it = chunkit('ab', 3)
-    assert list(it) == [['a', 'b']]
+    it = chunkit("ab", 3)
+    assert list(it) == [["a", "b"]]
 
-    it = chunkit('', 3)
+    it = chunkit("", 3)
     assert list(it) == []
 
 
@@ -839,86 +894,88 @@ data1 #data1
 data2
 
  data3
-""".splitlines(keepends=True)
-    assert list(clean_lines(conf)) == ['data1 #data1', 'data2', 'data3', ]
-    assert list(clean_lines(conf, lstrip=False)) == ['data1 #data1', 'data2', ' data3', ]
-    assert list(clean_lines(conf, rstrip=False)) == ['data1 #data1\n', 'data2\n', 'data3\n', ]
-    assert list(clean_lines(conf, remove_empty=False)) == ['data1 #data1', 'data2', '', 'data3', ]
-    assert list(clean_lines(conf, remove_comments=False)) == ['#comment', 'data1 #data1', 'data2', 'data3', ]
+""".splitlines(
+        keepends=True
+    )
+    assert list(clean_lines(conf)) == ["data1 #data1", "data2", "data3"]
+    assert list(clean_lines(conf, lstrip=False)) == ["data1 #data1", "data2", " data3"]
+    assert list(clean_lines(conf, rstrip=False)) == ["data1 #data1\n", "data2\n", "data3\n"]
+    assert list(clean_lines(conf, remove_empty=False)) == ["data1 #data1", "data2", "", "data3"]
+    assert list(clean_lines(conf, remove_comments=False)) == ["#comment", "data1 #data1", "data2", "data3"]
 
 
 def test_format_line():
-    data = dict(foo='bar baz')
-    assert format_line('', data) == ''
-    assert format_line('{foo}', data) == 'bar baz'
-    assert format_line('foo{foo}foo', data) == 'foobar bazfoo'
+    data = dict(foo="bar baz")
+    assert format_line("", data) == ""
+    assert format_line("{foo}", data) == "bar baz"
+    assert format_line("foo{foo}foo", data) == "foobar bazfoo"
 
 
 def test_format_line_erroneous():
     data = dict()
     with pytest.raises(PlaceholderError):
-        assert format_line('{invalid}', data)
+        assert format_line("{invalid}", data)
     with pytest.raises(PlaceholderError):
-        assert format_line('{}', data)
+        assert format_line("{}", data)
     with pytest.raises(PlaceholderError):
-        assert format_line('{now!r}', data)
+        assert format_line("{now!r}", data)
     with pytest.raises(PlaceholderError):
-        assert format_line('{now.__class__.__module__.__builtins__}', data)
+        assert format_line("{now.__class__.__module__.__builtins__}", data)
 
 
 def test_replace_placeholders():
     now = datetime.now()
-    assert " " not in replace_placeholders('{now}')
-    assert int(replace_placeholders('{now:%Y}')) == now.year
+    assert " " not in replace_placeholders("{now}")
+    assert int(replace_placeholders("{now:%Y}")) == now.year
 
 
 def test_override_placeholders():
-    assert replace_placeholders('{uuid4}', overrides={'uuid4': "overridden"}) == "overridden"
+    assert replace_placeholders("{uuid4}", overrides={"uuid4": "overridden"}) == "overridden"
 
 
 def working_swidth():
-    return platform.swidth('선') == 2
+    return platform.swidth("선") == 2
 
 
-@pytest.mark.skipif(not working_swidth(), reason='swidth() is not supported / active')
+@pytest.mark.skipif(not working_swidth(), reason="swidth() is not supported / active")
 def test_swidth_slice():
-    string = '나윤선나윤선나윤선나윤선나윤선'
-    assert swidth_slice(string, 1) == ''
-    assert swidth_slice(string, -1) == ''
-    assert swidth_slice(string, 4) == '나윤'
-    assert swidth_slice(string, -4) == '윤선'
+    string = "나윤선나윤선나윤선나윤선나윤선"
+    assert swidth_slice(string, 1) == ""
+    assert swidth_slice(string, -1) == ""
+    assert swidth_slice(string, 4) == "나윤"
+    assert swidth_slice(string, -4) == "윤선"
 
 
-@pytest.mark.skipif(not working_swidth(), reason='swidth() is not supported / active')
+@pytest.mark.skipif(not working_swidth(), reason="swidth() is not supported / active")
 def test_swidth_slice_mixed_characters():
-    string = '나윤a선나윤선나윤선나윤선나윤선'
-    assert swidth_slice(string, 5) == '나윤a'
-    assert swidth_slice(string, 6) == '나윤a'
+    string = "나윤a선나윤선나윤선나윤선나윤선"
+    assert swidth_slice(string, 5) == "나윤a"
+    assert swidth_slice(string, 6) == "나윤a"
 
 
 def test_safe_timestamps():
     if SUPPORT_32BIT_PLATFORMS:
         # ns fit into int64
-        assert safe_ns(2 ** 64) <= 2 ** 63 - 1
+        assert safe_ns(2**64) <= 2**63 - 1
         assert safe_ns(-1) == 0
         # s fit into int32
-        assert safe_s(2 ** 64) <= 2 ** 31 - 1
+        assert safe_s(2**64) <= 2**31 - 1
         assert safe_s(-1) == 0
         # datetime won't fall over its y10k problem
-        beyond_y10k = 2 ** 100
+        beyond_y10k = 2**100
         with pytest.raises(OverflowError):
             datetime.utcfromtimestamp(beyond_y10k)
         assert datetime.utcfromtimestamp(safe_s(beyond_y10k)) > datetime(2038, 1, 1)
         assert datetime.utcfromtimestamp(safe_ns(beyond_y10k) / 1000000000) > datetime(2038, 1, 1)
     else:
         # ns fit into int64
-        assert safe_ns(2 ** 64) <= 2 ** 63 - 1
+        assert safe_ns(2**64) <= 2**63 - 1
         assert safe_ns(-1) == 0
         # s are so that their ns conversion fits into int64
-        assert safe_s(2 ** 64) * 1000000000 <= 2 ** 63 - 1
+        assert safe_s(2**64) * 1000000000 <= 2**63 - 1
         assert safe_s(-1) == 0
         # datetime won't fall over its y10k problem
-        beyond_y10k = 2 ** 100
+        beyond_y10k = 2**100
         with pytest.raises(OverflowError):
             datetime.utcfromtimestamp(beyond_y10k)
         assert datetime.utcfromtimestamp(safe_s(beyond_y10k)) > datetime(2262, 1, 1)
@@ -926,66 +983,64 @@ def test_safe_timestamps():
 
 
 class TestPopenWithErrorHandling:
-    @pytest.mark.skipif(not shutil.which('test'), reason='"test" binary is needed')
+    @pytest.mark.skipif(not shutil.which("test"), reason='"test" binary is needed')
     def test_simple(self):
-        proc = popen_with_error_handling('test 1')
+        proc = popen_with_error_handling("test 1")
         assert proc.wait() == 0
 
-    @pytest.mark.skipif(shutil.which('borg-foobar-test-notexist'), reason='"borg-foobar-test-notexist" binary exists (somehow?)')
+    @pytest.mark.skipif(
+        shutil.which("borg-foobar-test-notexist"), reason='"borg-foobar-test-notexist" binary exists (somehow?)'
+    )
     def test_not_found(self):
-        proc = popen_with_error_handling('borg-foobar-test-notexist 1234')
+        proc = popen_with_error_handling("borg-foobar-test-notexist 1234")
         assert proc is None
 
-    @pytest.mark.parametrize('cmd', (
-            'mismatched "quote',
-            'foo --bar="baz',
-            ''
-    ))
+    @pytest.mark.parametrize("cmd", ('mismatched "quote', 'foo --bar="baz', ""))
     def test_bad_syntax(self, cmd):
         proc = popen_with_error_handling(cmd)
         assert proc is None
 
     def test_shell(self):
         with pytest.raises(AssertionError):
-            popen_with_error_handling('', shell=True)
+            popen_with_error_handling("", shell=True)
 
 
 def test_dash_open():
-    assert dash_open('-', 'r') is sys.stdin
-    assert dash_open('-', 'w') is sys.stdout
-    assert dash_open('-', 'rb') is sys.stdin.buffer
-    assert dash_open('-', 'wb') is sys.stdout.buffer
+    assert dash_open("-", "r") is sys.stdin
+    assert dash_open("-", "w") is sys.stdout
+    assert dash_open("-", "rb") is sys.stdin.buffer
+    assert dash_open("-", "wb") is sys.stdout.buffer
 
 
 def test_iter_separated():
     # newline and utf-8
-    sep, items = '\n', ['foo', 'bar/baz', 'αáčő']
+    sep, items = "\n", ["foo", "bar/baz", "αáčő"]
     fd = StringIO(sep.join(items))
     assert list(iter_separated(fd)) == items
     # null and bogus ending
-    sep, items = '\0', ['foo/bar', 'baz', 'spam']
-    fd = StringIO(sep.join(items) + '\0')
-    assert list(iter_separated(fd, sep=sep)) == ['foo/bar', 'baz', 'spam']
+    sep, items = "\0", ["foo/bar", "baz", "spam"]
+    fd = StringIO(sep.join(items) + "\0")
+    assert list(iter_separated(fd, sep=sep)) == ["foo/bar", "baz", "spam"]
     # multichar
-    sep, items = 'SEP', ['foo/bar', 'baz', 'spam']
+    sep, items = "SEP", ["foo/bar", "baz", "spam"]
     fd = StringIO(sep.join(items))
     assert list(iter_separated(fd, sep=sep)) == items
     # bytes
-    sep, items = b'\n', [b'foo', b'blop\t', b'gr\xe4ezi']
+    sep, items = b"\n", [b"foo", b"blop\t", b"gr\xe4ezi"]
     fd = BytesIO(sep.join(items))
     assert list(iter_separated(fd)) == items
 
 
 def test_eval_escapes():
-    assert eval_escapes('\\n\\0\\x23') == '\n\0#'
-    assert eval_escapes('äç\\n') == 'äç\n'
+    assert eval_escapes("\\n\\0\\x23") == "\n\0#"
+    assert eval_escapes("äç\\n") == "äç\n"
 
 
 def test_safe_unlink_is_safe(tmpdir):
     contents = b"Hello, world\n"
-    victim = tmpdir / 'victim'
+    victim = tmpdir / "victim"
     victim.write_binary(contents)
-    hard_link = tmpdir / 'hardlink'
+    hard_link = tmpdir / "hardlink"
     hard_link.mklinkto(victim)
 
     safe_unlink(hard_link)
@@ -995,13 +1050,14 @@ def test_safe_unlink_is_safe(tmpdir):
 
 def test_safe_unlink_is_safe_ENOSPC(tmpdir, monkeypatch):
     contents = b"Hello, world\n"
-    victim = tmpdir / 'victim'
+    victim = tmpdir / "victim"
     victim.write_binary(contents)
-    hard_link = tmpdir / 'hardlink'
+    hard_link = tmpdir / "hardlink"
     hard_link.mklinkto(victim)
 
     def os_unlink(_):
         raise OSError(errno.ENOSPC, "Pretend that we ran out of space")
+
     monkeypatch.setattr(os, "unlink", os_unlink)
 
     with pytest.raises(OSError):
@@ -1012,38 +1068,38 @@ def test_safe_unlink_is_safe_ENOSPC(tmpdir, monkeypatch):
 
 class TestPassphrase:
     def test_passphrase_new_verification(self, capsys, monkeypatch):
-        monkeypatch.setattr(getpass, 'getpass', lambda prompt: "12aöäü")
-        monkeypatch.setenv('BORG_DISPLAY_PASSPHRASE', 'no')
+        monkeypatch.setattr(getpass, "getpass", lambda prompt: "12aöäü")
+        monkeypatch.setenv("BORG_DISPLAY_PASSPHRASE", "no")
         Passphrase.new()
         out, err = capsys.readouterr()
         assert "12" not in out
         assert "12" not in err
 
-        monkeypatch.setenv('BORG_DISPLAY_PASSPHRASE', 'yes')
+        monkeypatch.setenv("BORG_DISPLAY_PASSPHRASE", "yes")
         passphrase = Passphrase.new()
         out, err = capsys.readouterr()
         assert "313261c3b6c3a4c3bc" not in out
         assert "313261c3b6c3a4c3bc" in err
         assert passphrase == "12aöäü"
 
-        monkeypatch.setattr(getpass, 'getpass', lambda prompt: "1234/@=")
+        monkeypatch.setattr(getpass, "getpass", lambda prompt: "1234/@=")
         Passphrase.new()
         out, err = capsys.readouterr()
         assert "1234/@=" not in out
         assert "1234/@=" in err
 
     def test_passphrase_new_empty(self, capsys, monkeypatch):
-        monkeypatch.delenv('BORG_PASSPHRASE', False)
-        monkeypatch.setattr(getpass, 'getpass', lambda prompt: "")
+        monkeypatch.delenv("BORG_PASSPHRASE", False)
+        monkeypatch.setattr(getpass, "getpass", lambda prompt: "")
         with pytest.raises(PasswordRetriesExceeded):
             Passphrase.new(allow_empty=False)
         out, err = capsys.readouterr()
         assert "must not be blank" in err
 
     def test_passphrase_new_retries(self, monkeypatch):
-        monkeypatch.delenv('BORG_PASSPHRASE', False)
+        monkeypatch.delenv("BORG_PASSPHRASE", False)
         ascending_numbers = iter(range(20))
-        monkeypatch.setattr(getpass, 'getpass', lambda prompt: str(next(ascending_numbers)))
+        monkeypatch.setattr(getpass, "getpass", lambda prompt: str(next(ascending_numbers)))
         with pytest.raises(PasswordRetriesExceeded):
             Passphrase.new()
 
diff --git a/src/borg/testsuite/item.py b/src/borg/testsuite/item.py
index 47f8e1021..e7cb9b2ac 100644
--- a/src/borg/testsuite/item.py
+++ b/src/borg/testsuite/item.py
@@ -11,20 +11,20 @@ def test_item_empty():
 
     assert item.as_dict() == {}
 
-    assert 'path' not in item
+    assert "path" not in item
     with pytest.raises(ValueError):
-        'invalid-key' in item
+        "invalid-key" in item
     with pytest.raises(TypeError):
-        b'path' in item
+        b"path" in item
     with pytest.raises(TypeError):
         42 in item
 
-    assert item.get('mode') is None
-    assert item.get('mode', 0o666) == 0o666
+    assert item.get("mode") is None
+    assert item.get("mode", 0o666) == 0o666
     with pytest.raises(ValueError):
-        item.get('invalid-key')
+        item.get("invalid-key")
     with pytest.raises(TypeError):
-        item.get(b'mode')
+        item.get(b"mode")
     with pytest.raises(TypeError):
         item.get(42)
 
@@ -37,16 +37,16 @@ def test_item_empty():
 
 def test_item_from_dict():
     # does not matter whether we get str or bytes keys
-    item = Item({b'path': '/a/b/c', b'mode': 0o666})
-    assert item.path == '/a/b/c'
+    item = Item({b"path": "/a/b/c", b"mode": 0o666})
+    assert item.path == "/a/b/c"
     assert item.mode == 0o666
-    assert 'path' in item
+    assert "path" in item
 
     # does not matter whether we get str or bytes keys
-    item = Item({'path': '/a/b/c', 'mode': 0o666})
-    assert item.path == '/a/b/c'
+    item = Item({"path": "/a/b/c", "mode": 0o666})
+    assert item.path == "/a/b/c"
     assert item.mode == 0o666
-    assert 'mode' in item
+    assert "mode" in item
 
     # invalid - no dict
     with pytest.raises(TypeError):
@@ -58,12 +58,12 @@ def test_item_from_dict():
 
     # invalid - unknown key
     with pytest.raises(ValueError):
-        Item({'foobar': 'baz'})
+        Item({"foobar": "baz"})
 
 
 def test_item_from_kw():
-    item = Item(path='/a/b/c', mode=0o666)
-    assert item.path == '/a/b/c'
+    item = Item(path="/a/b/c", mode=0o666)
+    assert item.path == "/a/b/c"
     assert item.mode == 0o666
 
 
@@ -71,7 +71,7 @@ def test_item_int_property():
     item = Item()
     item.mode = 0o666
     assert item.mode == 0o666
-    assert item.as_dict() == {'mode': 0o666}
+    assert item.as_dict() == {"mode": 0o666}
     del item.mode
     assert item.as_dict() == {}
     with pytest.raises(TypeError):
@@ -80,34 +80,34 @@ def test_item_int_property():
 
 def test_item_mptimestamp_property():
     item = Item()
-    small, big = 42, 2 ** 65
+    small, big = 42, 2**65
     item.atime = small
     assert item.atime == small
-    assert item.as_dict() == {'atime': Timestamp.from_unix_nano(small)}
+    assert item.as_dict() == {"atime": Timestamp.from_unix_nano(small)}
     item.atime = big
     assert item.atime == big
-    assert item.as_dict() == {'atime': Timestamp.from_unix_nano(big)}
+    assert item.as_dict() == {"atime": Timestamp.from_unix_nano(big)}
 
 
 def test_item_se_str_property():
     # start simple
     item = Item()
-    item.path = '/a/b/c'
-    assert item.path == '/a/b/c'
-    assert item.as_dict() == {'path': '/a/b/c'}
+    item.path = "/a/b/c"
+    assert item.path == "/a/b/c"
+    assert item.as_dict() == {"path": "/a/b/c"}
     del item.path
     assert item.as_dict() == {}
     with pytest.raises(TypeError):
         item.path = 42
 
     # non-utf-8 path, needing surrogate-escaping for latin-1 u-umlaut
-    item = Item(internal_dict={'path': b'/a/\xfc/c'})
-    assert item.path == '/a/\udcfc/c'  # getting a surrogate-escaped representation
-    assert item.as_dict() == {'path': '/a/\udcfc/c'}
+    item = Item(internal_dict={"path": b"/a/\xfc/c"})
+    assert item.path == "/a/\udcfc/c"  # getting a surrogate-escaped representation
+    assert item.as_dict() == {"path": "/a/\udcfc/c"}
     del item.path
-    assert 'path' not in item
-    item.path = '/a/\udcfc/c'  # setting using a surrogate-escaped representation
-    assert item.as_dict() == {'path': '/a/\udcfc/c'}
+    assert "path" not in item
+    item.path = "/a/\udcfc/c"  # setting using a surrogate-escaped representation
+    assert item.as_dict() == {"path": "/a/\udcfc/c"}
 
 
 def test_item_list_property():
@@ -118,18 +118,18 @@ def test_item_list_property():
     assert item.chunks == [0]
     item.chunks.append(1)
     assert item.chunks == [0, 1]
-    assert item.as_dict() == {'chunks': [0, 1]}
+    assert item.as_dict() == {"chunks": [0, 1]}
 
 
 def test_item_dict_property():
     item = Item()
     item.xattrs = StableDict()
     assert item.xattrs == StableDict()
-    item.xattrs['foo'] = 'bar'
-    assert item.xattrs['foo'] == 'bar'
-    item.xattrs['bar'] = 'baz'
-    assert item.xattrs == StableDict({'foo': 'bar', 'bar': 'baz'})
-    assert item.as_dict() == {'xattrs': {'foo': 'bar', 'bar': 'baz'}}
+    item.xattrs["foo"] = "bar"
+    assert item.xattrs["foo"] == "bar"
+    item.xattrs["bar"] = "baz"
+    assert item.xattrs == StableDict({"foo": "bar", "bar": "baz"})
+    assert item.as_dict() == {"xattrs": {"foo": "bar", "bar": "baz"}}
 
 
 def test_unknown_property():
@@ -142,10 +142,7 @@ def test_unknown_property():
 
 
 def test_item_file_size():
-    item = Item(mode=0o100666, chunks=[
-        ChunkListEntry(size=1000, id=None),
-        ChunkListEntry(size=2000, id=None),
-    ])
+    item = Item(mode=0o100666, chunks=[ChunkListEntry(size=1000, id=None), ChunkListEntry(size=2000, id=None)])
     assert item.get_size() == 3000
     item.get_size(memorize=True)
     assert item.size == 3000
diff --git a/src/borg/testsuite/key.py b/src/borg/testsuite/key.py
index 2b69e73b0..512649232 100644
--- a/src/borg/testsuite/key.py
+++ b/src/borg/testsuite/key.py
@@ -11,7 +11,13 @@ from ..crypto.key import RepoKey, KeyfileKey, Blake2RepoKey, Blake2KeyfileKey
 from ..crypto.key import AESOCBRepoKey, AESOCBKeyfileKey, CHPORepoKey, CHPOKeyfileKey
 from ..crypto.key import Blake2AESOCBRepoKey, Blake2AESOCBKeyfileKey, Blake2CHPORepoKey, Blake2CHPOKeyfileKey
 from ..crypto.key import ID_HMAC_SHA_256, ID_BLAKE2b_256
-from ..crypto.key import TAMRequiredError, TAMInvalid, TAMUnsupportedSuiteError, UnsupportedManifestError, UnsupportedKeyFormatError
+from ..crypto.key import (
+    TAMRequiredError,
+    TAMInvalid,
+    TAMUnsupportedSuiteError,
+    UnsupportedManifestError,
+    UnsupportedKeyFormatError,
+)
 from ..crypto.key import identify_key
 from ..crypto.low_level import IntegrityError as IntegrityErrorBase
 from ..helpers import IntegrityError
@@ -36,11 +42,17 @@ class TestKey:
         F84MsMMiqpbz4KVICeBZhfAaTPs4W7BC63qml0ZXJhdGlvbnPOAAGGoKRzYWx02gAgLENQ
         2uVCoR7EnAoiRzn8J+orbojKtJlNCnQ31SSC8rendmVyc2lvbgE=""".strip()
 
-    keyfile2_cdata = unhexlify(re.sub(r'\W', '', """
+    keyfile2_cdata = unhexlify(
+        re.sub(
+            r"\W",
+            "",
+            """
         0055f161493fcfc16276e8c31493c4641e1eb19a79d0326fad0291e5a9c98e5933
         00000000000003e8d21eaf9b86c297a8cd56432e1915bb
-        """))
-    keyfile2_id = unhexlify('c3fbf14bc001ebcc3cd86e696c13482ed071740927cd7cbe1b01b4bfcee49314')
+        """,
+        )
+    )
+    keyfile2_id = unhexlify("c3fbf14bc001ebcc3cd86e696c13482ed071740927cd7cbe1b01b4bfcee49314")
 
     keyfile_blake2_key_file = """
         BORG_KEY 0000000000000000000000000000000000000000000000000000000000000000
@@ -56,8 +68,9 @@ class TestKey:
         UTHFJg343jqml0ZXJhdGlvbnPOAAGGoKRzYWx02gAgz3YaUZZ/s+UWywj97EY5b4KhtJYi
         qkPqtDDxs2j/T7+ndmVyc2lvbgE=""".strip()
 
-    keyfile_blake2_cdata = bytes.fromhex('04fdf9475cf2323c0ba7a99ddc011064f2e7d039f539f2e448'
-                                         '0e6f5fc6ff9993d604040404040404098c8cee1c6db8c28947')
+    keyfile_blake2_cdata = bytes.fromhex(
+        "04fdf9475cf2323c0ba7a99ddc011064f2e7d039f539f2e448" "0e6f5fc6ff9993d604040404040404098c8cee1c6db8c28947"
+    )
     # Verified against b2sum. Entire string passed to BLAKE2, including the padded 64 byte key contained in
     # keyfile_blake2_key_file above is
     # 19280471de95185ec27ecb6fc9edbb4f4db26974c315ede1cd505fab4250ce7cd0d081ea66946c
@@ -65,33 +78,42 @@ class TestKey:
     # 000000000000000000000000000000000000000000000000000000000000000000000000000000
     # 00000000000000000000007061796c6f6164
     #                       p a y l o a d
-    keyfile_blake2_id = bytes.fromhex('d8bc68e961c79f99be39061589e5179b2113cd9226e07b08ddd4a1fef7ce93fb')
+    keyfile_blake2_id = bytes.fromhex("d8bc68e961c79f99be39061589e5179b2113cd9226e07b08ddd4a1fef7ce93fb")
 
     @pytest.fixture
     def keys_dir(self, request, monkeypatch, tmpdir):
-        monkeypatch.setenv('BORG_KEYS_DIR', str(tmpdir))
+        monkeypatch.setenv("BORG_KEYS_DIR", str(tmpdir))
         return tmpdir
 
-    @pytest.fixture(params=(
-        # not encrypted
-        PlaintextKey,
-        AuthenticatedKey, Blake2AuthenticatedKey,
-        # legacy crypto
-        KeyfileKey, Blake2KeyfileKey,
-        RepoKey, Blake2RepoKey,
-        # new crypto
-        AESOCBKeyfileKey, AESOCBRepoKey,
-        Blake2AESOCBKeyfileKey, Blake2AESOCBRepoKey,
-        CHPOKeyfileKey, CHPORepoKey,
-        Blake2CHPOKeyfileKey, Blake2CHPORepoKey,
-    ))
+    @pytest.fixture(
+        params=(
+            # not encrypted
+            PlaintextKey,
+            AuthenticatedKey,
+            Blake2AuthenticatedKey,
+            # legacy crypto
+            KeyfileKey,
+            Blake2KeyfileKey,
+            RepoKey,
+            Blake2RepoKey,
+            # new crypto
+            AESOCBKeyfileKey,
+            AESOCBRepoKey,
+            Blake2AESOCBKeyfileKey,
+            Blake2AESOCBRepoKey,
+            CHPOKeyfileKey,
+            CHPORepoKey,
+            Blake2CHPOKeyfileKey,
+            Blake2CHPORepoKey,
+        )
+    )
     def key(self, request, monkeypatch):
-        monkeypatch.setenv('BORG_PASSPHRASE', 'test')
+        monkeypatch.setenv("BORG_PASSPHRASE", "test")
         return request.param.create(self.MockRepository(), self.MockArgs())
 
     class MockRepository:
         class _Location:
-            raw = processed = '/some/place'
+            raw = processed = "/some/place"
 
             def canonical_path(self):
                 return self.processed
@@ -114,16 +136,16 @@ class TestKey:
 
     def test_plaintext(self):
         key = PlaintextKey.create(None, None)
-        chunk = b'foo'
+        chunk = b"foo"
         id = key.id_hash(chunk)
-        assert hexlify(id) == b'2c26b46b68ffc68ff99b453c1d30413413422d706483bfa0f98a5e886266e7ae'
+        assert hexlify(id) == b"2c26b46b68ffc68ff99b453c1d30413413422d706483bfa0f98a5e886266e7ae"
         assert chunk == key.decrypt(id, key.encrypt(id, chunk))
 
     def test_keyfile(self, monkeypatch, keys_dir):
-        monkeypatch.setenv('BORG_PASSPHRASE', 'test')
+        monkeypatch.setenv("BORG_PASSPHRASE", "test")
         key = KeyfileKey.create(self.MockRepository(), self.MockArgs())
         assert key.cipher.next_iv() == 0
-        chunk = b'ABC'
+        chunk = b"ABC"
         id = key.id_hash(chunk)
         manifest = key.encrypt(id, chunk)
         assert key.cipher.extract_iv(manifest) == 0
@@ -137,18 +159,18 @@ class TestKey:
         # Key data sanity check
         assert len({key2.id_key, key2.enc_key, key2.enc_hmac_key}) == 3
         assert key2.chunk_seed != 0
-        chunk = b'foo'
+        chunk = b"foo"
         id = key.id_hash(chunk)
         assert chunk == key2.decrypt(id, key.encrypt(id, chunk))
 
     def test_keyfile_kfenv(self, tmpdir, monkeypatch):
-        keyfile = tmpdir.join('keyfile')
-        monkeypatch.setenv('BORG_KEY_FILE', str(keyfile))
-        monkeypatch.setenv('BORG_PASSPHRASE', 'testkf')
+        keyfile = tmpdir.join("keyfile")
+        monkeypatch.setenv("BORG_KEY_FILE", str(keyfile))
+        monkeypatch.setenv("BORG_PASSPHRASE", "testkf")
         assert not keyfile.exists()
         key = CHPOKeyfileKey.create(self.MockRepository(), self.MockArgs())
         assert keyfile.exists()
-        chunk = b'ABC'
+        chunk = b"ABC"
         chunk_id = key.id_hash(chunk)
         chunk_cdata = key.encrypt(chunk_id, chunk)
         key = CHPOKeyfileKey.detect(self.MockRepository(), chunk_cdata)
@@ -158,27 +180,27 @@ class TestKey:
             CHPOKeyfileKey.detect(self.MockRepository(), chunk_cdata)
 
     def test_keyfile2(self, monkeypatch, keys_dir):
-        with keys_dir.join('keyfile').open('w') as fd:
+        with keys_dir.join("keyfile").open("w") as fd:
             fd.write(self.keyfile2_key_file)
-        monkeypatch.setenv('BORG_PASSPHRASE', 'passphrase')
+        monkeypatch.setenv("BORG_PASSPHRASE", "passphrase")
         key = KeyfileKey.detect(self.MockRepository(), self.keyfile2_cdata)
-        assert key.decrypt(self.keyfile2_id, self.keyfile2_cdata) == b'payload'
+        assert key.decrypt(self.keyfile2_id, self.keyfile2_cdata) == b"payload"
 
     def test_keyfile2_kfenv(self, tmpdir, monkeypatch):
-        keyfile = tmpdir.join('keyfile')
-        with keyfile.open('w') as fd:
+        keyfile = tmpdir.join("keyfile")
+        with keyfile.open("w") as fd:
             fd.write(self.keyfile2_key_file)
-        monkeypatch.setenv('BORG_KEY_FILE', str(keyfile))
-        monkeypatch.setenv('BORG_PASSPHRASE', 'passphrase')
+        monkeypatch.setenv("BORG_KEY_FILE", str(keyfile))
+        monkeypatch.setenv("BORG_PASSPHRASE", "passphrase")
         key = KeyfileKey.detect(self.MockRepository(), self.keyfile2_cdata)
-        assert key.decrypt(self.keyfile2_id, self.keyfile2_cdata) == b'payload'
+        assert key.decrypt(self.keyfile2_id, self.keyfile2_cdata) == b"payload"
 
     def test_keyfile_blake2(self, monkeypatch, keys_dir):
-        with keys_dir.join('keyfile').open('w') as fd:
+        with keys_dir.join("keyfile").open("w") as fd:
             fd.write(self.keyfile_blake2_key_file)
-        monkeypatch.setenv('BORG_PASSPHRASE', 'passphrase')
+        monkeypatch.setenv("BORG_PASSPHRASE", "passphrase")
         key = Blake2KeyfileKey.detect(self.MockRepository(), self.keyfile_blake2_cdata)
-        assert key.decrypt(self.keyfile_blake2_id, self.keyfile_blake2_cdata) == b'payload'
+        assert key.decrypt(self.keyfile_blake2_id, self.keyfile_blake2_cdata) == b"payload"
 
     def _corrupt_byte(self, key, data, offset):
         data = bytearray(data)
@@ -186,12 +208,12 @@ class TestKey:
         # will trigger an IntegrityError (does not happen while we stay within TYPES_ACCEPTABLE).
         data[offset] ^= 64
         with pytest.raises(IntegrityErrorBase):
-            key.decrypt(b'', data)
+            key.decrypt(b"", data)
 
     def test_decrypt_integrity(self, monkeypatch, keys_dir):
-        with keys_dir.join('keyfile').open('w') as fd:
+        with keys_dir.join("keyfile").open("w") as fd:
             fd.write(self.keyfile2_key_file)
-        monkeypatch.setenv('BORG_PASSPHRASE', 'passphrase')
+        monkeypatch.setenv("BORG_PASSPHRASE", "passphrase")
         key = KeyfileKey.detect(self.MockRepository(), self.keyfile2_cdata)
 
         data = self.keyfile2_cdata
@@ -206,7 +228,7 @@ class TestKey:
 
     def test_roundtrip(self, key):
         repository = key.repository
-        plaintext = b'foo'
+        plaintext = b"foo"
         id = key.id_hash(plaintext)
         encrypted = key.encrypt(id, plaintext)
         identified_key_class = identify_key(encrypted)
@@ -216,59 +238,59 @@ class TestKey:
         assert decrypted == plaintext
 
     def test_decrypt_decompress(self, key):
-        plaintext = b'123456789'
+        plaintext = b"123456789"
         id = key.id_hash(plaintext)
         encrypted = key.encrypt(id, plaintext)
         assert key.decrypt(id, encrypted, decompress=False) != plaintext
         assert key.decrypt(id, encrypted) == plaintext
 
     def test_assert_id(self, key):
-        plaintext = b'123456789'
+        plaintext = b"123456789"
         id = key.id_hash(plaintext)
         key.assert_id(id, plaintext)
         id_changed = bytearray(id)
         id_changed[0] ^= 1
         with pytest.raises(IntegrityError):
             key.assert_id(id_changed, plaintext)
-        plaintext_changed = plaintext + b'1'
+        plaintext_changed = plaintext + b"1"
         with pytest.raises(IntegrityError):
             key.assert_id(id, plaintext_changed)
 
     def test_authenticated_encrypt(self, monkeypatch):
-        monkeypatch.setenv('BORG_PASSPHRASE', 'test')
+        monkeypatch.setenv("BORG_PASSPHRASE", "test")
         key = AuthenticatedKey.create(self.MockRepository(), self.MockArgs())
         assert AuthenticatedKey.id_hash is ID_HMAC_SHA_256.id_hash
         assert len(key.id_key) == 32
-        plaintext = b'123456789'
+        plaintext = b"123456789"
         id = key.id_hash(plaintext)
         authenticated = key.encrypt(id, plaintext)
         # 0x07 is the key TYPE, \x00ff identifies no compression / unknown level.
-        assert authenticated == b'\x07\x00\xff' + plaintext
+        assert authenticated == b"\x07\x00\xff" + plaintext
 
     def test_blake2_authenticated_encrypt(self, monkeypatch):
-        monkeypatch.setenv('BORG_PASSPHRASE', 'test')
+        monkeypatch.setenv("BORG_PASSPHRASE", "test")
         key = Blake2AuthenticatedKey.create(self.MockRepository(), self.MockArgs())
         assert Blake2AuthenticatedKey.id_hash is ID_BLAKE2b_256.id_hash
         assert len(key.id_key) == 128
-        plaintext = b'123456789'
+        plaintext = b"123456789"
         id = key.id_hash(plaintext)
         authenticated = key.encrypt(id, plaintext)
         # 0x06 is the key TYPE, 0x00ff identifies no compression / unknown level.
-        assert authenticated == b'\x06\x00\xff' + plaintext
+        assert authenticated == b"\x06\x00\xff" + plaintext
 
 
 class TestTAM:
     @pytest.fixture
     def key(self, monkeypatch):
-        monkeypatch.setenv('BORG_PASSPHRASE', 'test')
+        monkeypatch.setenv("BORG_PASSPHRASE", "test")
         return CHPOKeyfileKey.create(TestKey.MockRepository(), TestKey.MockArgs())
 
     def test_unpack_future(self, key):
-        blob = b'\xc1\xc1\xc1\xc1foobar'
+        blob = b"\xc1\xc1\xc1\xc1foobar"
         with pytest.raises(UnsupportedManifestError):
             key.unpack_and_verify_manifest(blob)
 
-        blob = b'\xc1\xc1\xc1'
+        blob = b"\xc1\xc1\xc1"
         with pytest.raises(msgpack.UnpackException):
             key.unpack_and_verify_manifest(blob)
 
@@ -285,84 +307,66 @@ class TestTAM:
         assert not verified
 
     def test_unknown_type_when_required(self, key):
-        blob = msgpack.packb({
-            'tam': {
-                'type': 'HMAC_VOLLBIT',
-            },
-        })
+        blob = msgpack.packb({"tam": {"type": "HMAC_VOLLBIT"}})
         with pytest.raises(TAMUnsupportedSuiteError):
             key.unpack_and_verify_manifest(blob)
 
     def test_unknown_type(self, key):
-        blob = msgpack.packb({
-            'tam': {
-                'type': 'HMAC_VOLLBIT',
-            },
-        })
+        blob = msgpack.packb({"tam": {"type": "HMAC_VOLLBIT"}})
         key.tam_required = False
         unpacked, verified = key.unpack_and_verify_manifest(blob)
         assert unpacked == {}
         assert not verified
 
-    @pytest.mark.parametrize('tam, exc', (
-        ({}, TAMUnsupportedSuiteError),
-        ({'type': b'\xff'}, TAMUnsupportedSuiteError),
-        (None, TAMInvalid),
-        (1234, TAMInvalid),
-    ))
+    @pytest.mark.parametrize(
+        "tam, exc",
+        (
+            ({}, TAMUnsupportedSuiteError),
+            ({"type": b"\xff"}, TAMUnsupportedSuiteError),
+            (None, TAMInvalid),
+            (1234, TAMInvalid),
+        ),
+    )
     def test_invalid(self, key, tam, exc):
-        blob = msgpack.packb({
-            'tam': tam,
-        })
+        blob = msgpack.packb({"tam": tam})
         with pytest.raises(exc):
             key.unpack_and_verify_manifest(blob)
 
-    @pytest.mark.parametrize('hmac, salt', (
-        ({}, bytes(64)),
-        (bytes(64), {}),
-        (None, bytes(64)),
-        (bytes(64), None),
-    ))
+    @pytest.mark.parametrize("hmac, salt", (({}, bytes(64)), (bytes(64), {}), (None, bytes(64)), (bytes(64), None)))
     def test_wrong_types(self, key, hmac, salt):
-        data = {
-            'tam': {
-                'type': 'HKDF_HMAC_SHA512',
-                'hmac': hmac,
-                'salt': salt
-            },
-        }
-        tam = data['tam']
+        data = {"tam": {"type": "HKDF_HMAC_SHA512", "hmac": hmac, "salt": salt}}
+        tam = data["tam"]
         if hmac is None:
-            del tam['hmac']
+            del tam["hmac"]
         if salt is None:
-            del tam['salt']
+            del tam["salt"]
         blob = msgpack.packb(data)
         with pytest.raises(TAMInvalid):
             key.unpack_and_verify_manifest(blob)
 
     def test_round_trip(self, key):
-        data = {'foo': 'bar'}
+        data = {"foo": "bar"}
         blob = key.pack_and_authenticate_metadata(data)
-        assert blob.startswith(b'\x82')
+        assert blob.startswith(b"\x82")
 
         unpacked = msgpack.unpackb(blob)
-        assert unpacked['tam']['type'] == 'HKDF_HMAC_SHA512'
+        assert unpacked["tam"]["type"] == "HKDF_HMAC_SHA512"
 
         unpacked, verified = key.unpack_and_verify_manifest(blob)
         assert verified
-        assert unpacked['foo'] == 'bar'
-        assert 'tam' not in unpacked
+        assert unpacked["foo"] == "bar"
+        assert "tam" not in unpacked
 
-    @pytest.mark.parametrize('which', ('hmac', 'salt'))
+    @pytest.mark.parametrize("which", ("hmac", "salt"))
     def test_tampered(self, key, which):
-        data = {'foo': 'bar'}
+        data = {"foo": "bar"}
         blob = key.pack_and_authenticate_metadata(data)
-        assert blob.startswith(b'\x82')
+        assert blob.startswith(b"\x82")
 
         unpacked = msgpack.unpackb(blob, object_hook=StableDict)
-        assert len(unpacked['tam'][which]) == 64
-        unpacked['tam'][which] = unpacked['tam'][which][0:32] + bytes(32)
-        assert len(unpacked['tam'][which]) == 64
+        assert len(unpacked["tam"][which]) == 64
+        unpacked["tam"][which] = unpacked["tam"][which][0:32] + bytes(32)
+        assert len(unpacked["tam"][which]) == 64
         blob = msgpack.packb(unpacked)
 
         with pytest.raises(TAMInvalid):
@@ -372,10 +376,7 @@ class TestTAM:
 def test_decrypt_key_file_unsupported_algorithm():
     """We will add more algorithms in the future. We should raise a helpful error."""
     key = CHPOKeyfileKey(None)
-    encrypted = msgpack.packb({
-        'algorithm': 'THIS ALGORITHM IS NOT SUPPORTED',
-        'version': 1,
-    })
+    encrypted = msgpack.packb({"algorithm": "THIS ALGORITHM IS NOT SUPPORTED", "version": 1})
 
     with pytest.raises(UnsupportedKeyFormatError):
         key.decrypt_key_file(encrypted, "hello, pass phrase")
@@ -384,9 +385,7 @@ def test_decrypt_key_file_unsupported_algorithm():
 def test_decrypt_key_file_v2_is_unsupported():
     """There may eventually be a version 2 of the format. For now we should raise a helpful error."""
     key = CHPOKeyfileKey(None)
-    encrypted = msgpack.packb({
-        'version': 2,
-    })
+    encrypted = msgpack.packb({"version": 2})
 
     with pytest.raises(UnsupportedKeyFormatError):
         key.decrypt_key_file(encrypted, "hello, pass phrase")
@@ -394,16 +393,16 @@ def test_decrypt_key_file_v2_is_unsupported():
 
 def test_key_file_roundtrip(monkeypatch):
     def to_dict(key):
-        extract = 'repository_id', 'enc_key', 'enc_hmac_key', 'id_key', 'chunk_seed'
+        extract = "repository_id", "enc_key", "enc_hmac_key", "id_key", "chunk_seed"
         return {a: getattr(key, a) for a in extract}
 
-    repository = MagicMock(id=b'repository_id')
-    monkeypatch.setenv('BORG_PASSPHRASE', "hello, pass phrase")
+    repository = MagicMock(id=b"repository_id")
+    monkeypatch.setenv("BORG_PASSPHRASE", "hello, pass phrase")
 
-    save_me = AESOCBRepoKey.create(repository, args=MagicMock(key_algorithm='argon2'))
+    save_me = AESOCBRepoKey.create(repository, args=MagicMock(key_algorithm="argon2"))
     saved = repository.save_key.call_args.args[0]
     repository.load_key.return_value = saved
     load_me = AESOCBRepoKey.detect(repository, manifest_data=None)
 
     assert to_dict(load_me) == to_dict(save_me)
-    assert msgpack.unpackb(a2b_base64(saved))['algorithm'] == KEY_ALGORITHMS['argon2']
+    assert msgpack.unpackb(a2b_base64(saved))["algorithm"] == KEY_ALGORITHMS["argon2"]
diff --git a/src/borg/testsuite/locking.py b/src/borg/testsuite/locking.py
index 656909ac5..69a47bb58 100644
--- a/src/borg/testsuite/locking.py
+++ b/src/borg/testsuite/locking.py
@@ -6,8 +6,19 @@ from traceback import format_exc
 import pytest
 
 from ..platform import get_process_id, process_alive
-from ..locking import TimeoutTimer, ExclusiveLock, Lock, LockRoster, \
-                      ADD, REMOVE, SHARED, EXCLUSIVE, LockTimeout, NotLocked, NotMyLock
+from ..locking import (
+    TimeoutTimer,
+    ExclusiveLock,
+    Lock,
+    LockRoster,
+    ADD,
+    REMOVE,
+    SHARED,
+    EXCLUSIVE,
+    LockTimeout,
+    NotLocked,
+    NotMyLock,
+)
 
 ID1 = "foo", 1, 1
 ID2 = "bar", 2, 2
@@ -45,7 +56,7 @@ class TestTimeoutTimer:
 
 @pytest.fixture()
 def lockpath(tmpdir):
-    return str(tmpdir.join('lock'))
+    return str(tmpdir.join("lock"))
 
 
 class TestExclusiveLock:
@@ -67,7 +78,7 @@ class TestExclusiveLock:
     def test_kill_stale(self, lockpath, free_pid):
         host, pid, tid = our_id = get_process_id()
         dead_id = host, free_pid, tid
-        cant_know_if_dead_id = 'foo.bar.example.net', 1, 2
+        cant_know_if_dead_id = "foo.bar.example.net", 1, 2
 
         dead_lock = ExclusiveLock(lockpath, id=dead_id).acquire()
         with ExclusiveLock(lockpath, id=our_id):
@@ -94,9 +105,7 @@ class TestExclusiveLock:
         assert old_unique_name != new_unique_name  # locking filename is different now
 
     def test_race_condition(self, lockpath):
-
         class SynchronizedCounter:
-
             def __init__(self, count=0):
                 self.lock = ThreadingLock()
                 self.count = count
@@ -126,44 +135,77 @@ class TestExclusiveLock:
             with print_lock:
                 print(msg)
 
-        def acquire_release_loop(id, timeout, thread_id, lock_owner_counter, exception_counter, print_lock, last_thread=None):
-            print_locked("Thread %2d: Starting acquire_release_loop(id=%s, timeout=%d); lockpath=%s" % (thread_id, id, timeout, lockpath))
+        def acquire_release_loop(
+            id, timeout, thread_id, lock_owner_counter, exception_counter, print_lock, last_thread=None
+        ):
+            print_locked(
+                "Thread %2d: Starting acquire_release_loop(id=%s, timeout=%d); lockpath=%s"
+                % (thread_id, id, timeout, lockpath)
+            )
             timer = TimeoutTimer(timeout, -1).start()
             cycle = 0
 
             while not timer.timed_out():
                 cycle += 1
                 try:
-                    with ExclusiveLock(lockpath, id=id, timeout=timeout/20, sleep=-1):  # This timeout is only for not exceeding the given timeout by more than 5%. With sleep<0 it's constantly polling anyway.
+                    with ExclusiveLock(
+                        lockpath, id=id, timeout=timeout / 20, sleep=-1
+                    ):  # This timeout is only for not exceeding the given timeout by more than 5%. With sleep<0 it's constantly polling anyway.
                         lock_owner_count = lock_owner_counter.incr()
-                        print_locked("Thread %2d: Acquired the lock. It's my %d. loop cycle. I am the %d. who has the lock concurrently." % (thread_id, cycle, lock_owner_count))
+                        print_locked(
+                            "Thread %2d: Acquired the lock. It's my %d. loop cycle. I am the %d. who has the lock concurrently."
+                            % (thread_id, cycle, lock_owner_count)
+                        )
                         time.sleep(0.005)
                         lock_owner_count = lock_owner_counter.decr()
-                        print_locked("Thread %2d: Releasing the lock, finishing my %d. loop cycle. Currently, %d colleagues still have the lock." % (thread_id, cycle, lock_owner_count))
+                        print_locked(
+                            "Thread %2d: Releasing the lock, finishing my %d. loop cycle. Currently, %d colleagues still have the lock."
+                            % (thread_id, cycle, lock_owner_count)
+                        )
                 except LockTimeout:
                     print_locked("Thread %2d: Got LockTimeout, finishing my %d. loop cycle." % (thread_id, cycle))
                 except:
                     exception_count = exception_counter.incr()
                     e = format_exc()
-                    print_locked("Thread %2d: Exception thrown, finishing my %d. loop cycle. It's the %d. exception seen until now: %s" % (thread_id, cycle, exception_count, e))
+                    print_locked(
+                        "Thread %2d: Exception thrown, finishing my %d. loop cycle. It's the %d. exception seen until now: %s"
+                        % (thread_id, cycle, exception_count, e)
+                    )
 
             print_locked("Thread %2d: Loop timed out--terminating after %d loop cycles." % (thread_id, cycle))
             if last_thread is not None:  # joining its predecessor, if any
                 last_thread.join()
 
-        print('')
+        print("")
         lock_owner_counter = SynchronizedCounter()
         exception_counter = SynchronizedCounter()
         print_lock = ThreadingLock()
         thread = None
         for thread_id in range(RACE_TEST_NUM_THREADS):
-            thread = Thread(target=acquire_release_loop, args=(('foo', thread_id, 0), RACE_TEST_DURATION, thread_id, lock_owner_counter, exception_counter, print_lock, thread))
+            thread = Thread(
+                target=acquire_release_loop,
+                args=(
+                    ("foo", thread_id, 0),
+                    RACE_TEST_DURATION,
+                    thread_id,
+                    lock_owner_counter,
+                    exception_counter,
+                    print_lock,
+                    thread,
+                ),
+            )
             thread.start()
         thread.join()  # joining the last thread
 
-        assert lock_owner_counter.maxvalue() > 0, 'Never gained the lock? Something went wrong here...'
-        assert lock_owner_counter.maxvalue() <= 1, "Maximal number of concurrent lock holders was %d. So exclusivity is broken." % (lock_owner_counter.maxvalue())
-        assert exception_counter.value() == 0, "ExclusiveLock threw %d exceptions due to unclean concurrency handling." % (exception_counter.value())
+        assert lock_owner_counter.maxvalue() > 0, "Never gained the lock? Something went wrong here..."
+        assert (
+            lock_owner_counter.maxvalue() <= 1
+        ), "Maximal number of concurrent lock holders was %d. So exclusivity is broken." % (
+            lock_owner_counter.maxvalue()
+        )
+        assert (
+            exception_counter.value() == 0
+        ), "ExclusiveLock threw %d exceptions due to unclean concurrency handling." % (exception_counter.value())
 
 
 class TestLock:
@@ -228,7 +270,7 @@ class TestLock:
     def test_kill_stale(self, lockpath, free_pid):
         host, pid, tid = our_id = get_process_id()
         dead_id = host, free_pid, tid
-        cant_know_if_dead_id = 'foo.bar.example.net', 1, 2
+        cant_know_if_dead_id = "foo.bar.example.net", 1, 2
 
         dead_lock = Lock(lockpath, id=dead_id, exclusive=True).acquire()
         roster = dead_lock._roster
@@ -263,7 +305,7 @@ class TestLock:
 
 @pytest.fixture()
 def rosterpath(tmpdir):
-    return str(tmpdir.join('roster'))
+    return str(tmpdir.join("roster"))
 
 
 class TestLockRoster:
@@ -277,13 +319,13 @@ class TestLockRoster:
         roster1 = LockRoster(rosterpath, id=ID1)
         assert roster1.get(SHARED) == set()
         roster1.modify(SHARED, ADD)
-        assert roster1.get(SHARED) == {ID1, }
+        assert roster1.get(SHARED) == {ID1}
         roster2 = LockRoster(rosterpath, id=ID2)
         roster2.modify(SHARED, ADD)
-        assert roster2.get(SHARED) == {ID1, ID2, }
+        assert roster2.get(SHARED) == {ID1, ID2}
         roster1 = LockRoster(rosterpath, id=ID1)
         roster1.modify(SHARED, REMOVE)
-        assert roster1.get(SHARED) == {ID2, }
+        assert roster1.get(SHARED) == {ID2}
         roster2 = LockRoster(rosterpath, id=ID2)
         roster2.modify(SHARED, REMOVE)
         assert roster2.get(SHARED) == set()
@@ -300,7 +342,7 @@ class TestLockRoster:
         assert roster1.get(SHARED) == {dead_id}
 
         # put a unknown-state remote process lock into roster
-        cant_know_if_dead_id = 'foo.bar.example.net', 1, 2
+        cant_know_if_dead_id = "foo.bar.example.net", 1, 2
         roster1 = LockRoster(rosterpath, id=cant_know_if_dead_id)
         roster1.kill_stale_locks = False
         assert roster1.get(SHARED) == {dead_id}
diff --git a/src/borg/testsuite/logger.py b/src/borg/testsuite/logger.py
index b6dc29653..d24ec0fd1 100644
--- a/src/borg/testsuite/logger.py
+++ b/src/borg/testsuite/logger.py
@@ -4,6 +4,7 @@ from io import StringIO
 import pytest
 
 from ..logger import find_parent_module, create_logger, setup_logging
+
 logger = create_logger()
 
 
@@ -11,27 +12,27 @@ logger = create_logger()
 def io_logger():
     io = StringIO()
     handler = setup_logging(stream=io, env_var=None)
-    handler.setFormatter(logging.Formatter('%(name)s: %(message)s'))
+    handler.setFormatter(logging.Formatter("%(name)s: %(message)s"))
     logger.setLevel(logging.DEBUG)
     return io
 
 
 def test_setup_logging(io_logger):
-    logger.info('hello world')
+    logger.info("hello world")
     assert io_logger.getvalue() == "borg.testsuite.logger: hello world\n"
 
 
 def test_multiple_loggers(io_logger):
     logger = logging.getLogger(__name__)
-    logger.info('hello world 1')
+    logger.info("hello world 1")
     assert io_logger.getvalue() == "borg.testsuite.logger: hello world 1\n"
-    logger = logging.getLogger('borg.testsuite.logger')
-    logger.info('hello world 2')
+    logger = logging.getLogger("borg.testsuite.logger")
+    logger.info("hello world 2")
     assert io_logger.getvalue() == "borg.testsuite.logger: hello world 1\nborg.testsuite.logger: hello world 2\n"
     io_logger.truncate(0)
     io_logger.seek(0)
-    logger = logging.getLogger('borg.testsuite.logger')
-    logger.info('hello world 2')
+    logger = logging.getLogger("borg.testsuite.logger")
+    logger.info("hello world 2")
     assert io_logger.getvalue() == "borg.testsuite.logger: hello world 2\n"
 
 
diff --git a/src/borg/testsuite/lrucache.py b/src/borg/testsuite/lrucache.py
index 6d1ab4adf..79bb734c4 100644
--- a/src/borg/testsuite/lrucache.py
+++ b/src/borg/testsuite/lrucache.py
@@ -6,33 +6,32 @@ from ..lrucache import LRUCache
 
 
 class TestLRUCache:
-
     def test_lrucache(self):
         c = LRUCache(2, dispose=lambda _: None)
         assert len(c) == 0
         assert c.items() == set()
-        for i, x in enumerate('abc'):
+        for i, x in enumerate("abc"):
             c[x] = i
         assert len(c) == 2
-        assert c.items() == {('b', 1), ('c', 2)}
-        assert 'a' not in c
-        assert 'b' in c
+        assert c.items() == {("b", 1), ("c", 2)}
+        assert "a" not in c
+        assert "b" in c
         with pytest.raises(KeyError):
-            c['a']
-        assert c.get('a') is None
-        assert c.get('a', 'foo') == 'foo'
-        assert c['b'] == 1
-        assert c.get('b') == 1
-        assert c['c'] == 2
-        c['d'] = 3
+            c["a"]
+        assert c.get("a") is None
+        assert c.get("a", "foo") == "foo"
+        assert c["b"] == 1
+        assert c.get("b") == 1
+        assert c["c"] == 2
+        c["d"] = 3
         assert len(c) == 2
-        assert c['c'] == 2
-        assert c['d'] == 3
-        del c['c']
+        assert c["c"] == 2
+        assert c["d"] == 3
+        del c["c"]
         assert len(c) == 1
         with pytest.raises(KeyError):
-            c['c']
-        assert c['d'] == 3
+            c["c"]
+        assert c["d"] == 3
         c.clear()
         assert c.items() == set()
 
diff --git a/src/borg/testsuite/nanorst.py b/src/borg/testsuite/nanorst.py
index b25336b62..fad21d842 100644
--- a/src/borg/testsuite/nanorst.py
+++ b/src/borg/testsuite/nanorst.py
@@ -4,15 +4,15 @@ from ..nanorst import rst_to_text
 
 
 def test_inline():
-    assert rst_to_text('*foo* and ``bar``.') == 'foo and bar.'
+    assert rst_to_text("*foo* and ``bar``.") == "foo and bar."
 
 
 def test_inline_spread():
-    assert rst_to_text('*foo and bar, thusly\nfoobar*.') == 'foo and bar, thusly\nfoobar.'
+    assert rst_to_text("*foo and bar, thusly\nfoobar*.") == "foo and bar, thusly\nfoobar."
 
 
 def test_comment_inline():
-    assert rst_to_text('Foo and Bar\n.. foo\nbar') == 'Foo and Bar\n.. foo\nbar'
+    assert rst_to_text("Foo and Bar\n.. foo\nbar") == "Foo and Bar\n.. foo\nbar"
 
 
 def test_inline_escape():
@@ -20,21 +20,19 @@ def test_inline_escape():
 
 
 def test_comment():
-    assert rst_to_text('Foo and Bar\n\n.. foo\nbar') == 'Foo and Bar\n\nbar'
+    assert rst_to_text("Foo and Bar\n\n.. foo\nbar") == "Foo and Bar\n\nbar"
 
 
 def test_directive_note():
-    assert rst_to_text('.. note::\n   Note this and that') == 'Note:\n   Note this and that'
+    assert rst_to_text(".. note::\n   Note this and that") == "Note:\n   Note this and that"
 
 
 def test_ref():
-    references = {
-        'foo': 'baz'
-    }
-    assert rst_to_text('See :ref:`fo\no`.', references=references) == 'See baz.'
+    references = {"foo": "baz"}
+    assert rst_to_text("See :ref:`fo\no`.", references=references) == "See baz."
 
 
 def test_undefined_ref():
     with pytest.raises(ValueError) as exc_info:
-        rst_to_text('See :ref:`foo`.')
-    assert 'Undefined reference' in str(exc_info.value)
+        rst_to_text("See :ref:`foo`.")
+    assert "Undefined reference" in str(exc_info.value)
diff --git a/src/borg/testsuite/nonces.py b/src/borg/testsuite/nonces.py
index 6d6701631..d9548fa91 100644
--- a/src/borg/testsuite/nonces.py
+++ b/src/borg/testsuite/nonces.py
@@ -10,10 +10,9 @@ from ..remote import InvalidRPCMethod
 
 
 class TestNonceManager:
-
     class MockRepository:
         class _Location:
-            orig = '/some/place'
+            orig = "/some/place"
 
         _location = _Location()
         id = bytes(32)
@@ -37,15 +36,15 @@ class TestNonceManager:
         self.repository = None
 
     def cache_nonce(self):
-        with open(os.path.join(get_security_dir(self.repository.id_str), 'nonce')) as fd:
+        with open(os.path.join(get_security_dir(self.repository.id_str), "nonce")) as fd:
             return fd.read()
 
     def set_cache_nonce(self, nonce):
-        with open(os.path.join(get_security_dir(self.repository.id_str), 'nonce'), "w") as fd:
+        with open(os.path.join(get_security_dir(self.repository.id_str), "nonce"), "w") as fd:
             assert fd.write(nonce)
 
     def test_empty_cache_and_old_server(self, monkeypatch):
-        monkeypatch.setattr(nonces, 'NONCE_SPACE_RESERVATION', 0x20)
+        monkeypatch.setattr(nonces, "NONCE_SPACE_RESERVATION", 0x20)
 
         self.repository = self.MockOldRepository()
         manager = NonceManager(self.repository, 0x2000)
@@ -55,7 +54,7 @@ class TestNonceManager:
         assert self.cache_nonce() == "0000000000002033"
 
     def test_empty_cache(self, monkeypatch):
-        monkeypatch.setattr(nonces, 'NONCE_SPACE_RESERVATION', 0x20)
+        monkeypatch.setattr(nonces, "NONCE_SPACE_RESERVATION", 0x20)
 
         self.repository = self.MockRepository()
         self.repository.next_free = 0x2000
@@ -66,7 +65,7 @@ class TestNonceManager:
         assert self.cache_nonce() == "0000000000002033"
 
     def test_empty_nonce(self, monkeypatch):
-        monkeypatch.setattr(nonces, 'NONCE_SPACE_RESERVATION', 0x20)
+        monkeypatch.setattr(nonces, "NONCE_SPACE_RESERVATION", 0x20)
 
         self.repository = self.MockRepository()
         self.repository.next_free = None
@@ -99,10 +98,10 @@ class TestNonceManager:
         next_nonce = manager.ensure_reservation(0x2043, 64)
         assert next_nonce == 0x2063
         assert self.cache_nonce() == "00000000000020c3"
-        assert self.repository.next_free == 0x20c3
+        assert self.repository.next_free == 0x20C3
 
     def test_sync_nonce(self, monkeypatch):
-        monkeypatch.setattr(nonces, 'NONCE_SPACE_RESERVATION', 0x20)
+        monkeypatch.setattr(nonces, "NONCE_SPACE_RESERVATION", 0x20)
 
         self.repository = self.MockRepository()
         self.repository.next_free = 0x2000
@@ -116,7 +115,7 @@ class TestNonceManager:
         assert self.repository.next_free == 0x2033
 
     def test_server_just_upgraded(self, monkeypatch):
-        monkeypatch.setattr(nonces, 'NONCE_SPACE_RESERVATION', 0x20)
+        monkeypatch.setattr(nonces, "NONCE_SPACE_RESERVATION", 0x20)
 
         self.repository = self.MockRepository()
         self.repository.next_free = None
@@ -130,7 +129,7 @@ class TestNonceManager:
         assert self.repository.next_free == 0x2033
 
     def test_transaction_abort_no_cache(self, monkeypatch):
-        monkeypatch.setattr(nonces, 'NONCE_SPACE_RESERVATION', 0x20)
+        monkeypatch.setattr(nonces, "NONCE_SPACE_RESERVATION", 0x20)
 
         self.repository = self.MockRepository()
         self.repository.next_free = 0x2000
@@ -143,7 +142,7 @@ class TestNonceManager:
         assert self.repository.next_free == 0x2033
 
     def test_transaction_abort_old_server(self, monkeypatch):
-        monkeypatch.setattr(nonces, 'NONCE_SPACE_RESERVATION', 0x20)
+        monkeypatch.setattr(nonces, "NONCE_SPACE_RESERVATION", 0x20)
 
         self.repository = self.MockOldRepository()
         self.set_cache_nonce("0000000000002000")
@@ -155,7 +154,7 @@ class TestNonceManager:
         assert self.cache_nonce() == "0000000000002033"
 
     def test_transaction_abort_on_other_client(self, monkeypatch):
-        monkeypatch.setattr(nonces, 'NONCE_SPACE_RESERVATION', 0x20)
+        monkeypatch.setattr(nonces, "NONCE_SPACE_RESERVATION", 0x20)
 
         self.repository = self.MockRepository()
         self.repository.next_free = 0x2000
@@ -169,7 +168,7 @@ class TestNonceManager:
         assert self.repository.next_free == 0x2033
 
     def test_interleaved(self, monkeypatch):
-        monkeypatch.setattr(nonces, 'NONCE_SPACE_RESERVATION', 0x20)
+        monkeypatch.setattr(nonces, "NONCE_SPACE_RESERVATION", 0x20)
 
         self.repository = self.MockRepository()
         self.repository.next_free = 0x2000
@@ -192,7 +191,7 @@ class TestNonceManager:
         assert self.repository.next_free == 0x4000
 
         # spans reservation boundary
-        next_nonce = manager.ensure_reservation(0x201f, 21)
+        next_nonce = manager.ensure_reservation(0x201F, 21)
         assert next_nonce == 0x4000
         assert self.cache_nonce() == "0000000000004035"
         assert self.repository.next_free == 0x4035
diff --git a/src/borg/testsuite/patterns.py b/src/borg/testsuite/patterns.py
index e26ead1e8..5c8a2b12b 100644
--- a/src/borg/testsuite/patterns.py
+++ b/src/borg/testsuite/patterns.py
@@ -11,8 +11,7 @@ from ..patterns import parse_pattern, PatternMatcher
 
 
 def check_patterns(files, pattern, expected):
-    """Utility for testing patterns.
-    """
+    """Utility for testing patterns."""
     assert all([f == os.path.normpath(f) for f in files]), "Pattern matchers expect normalized input paths"
 
     matched = [f for f in files if pattern.match(f)]
@@ -20,167 +19,291 @@ def check_patterns(files, pattern, expected):
     assert matched == (files if expected is None else expected)
 
 
-@pytest.mark.parametrize("pattern, expected", [
-    # "None" means all files, i.e. all match the given pattern
-    ("/", []),
-    ("/home", ["home"]),
-    ("/home///", ["home"]),
-    ("/./home", ["home"]),
-    ("/home/user", ["home/user"]),
-    ("/home/user2", ["home/user2"]),
-    ("/home/user/.bashrc", ["home/user/.bashrc"]),
-    ])
+@pytest.mark.parametrize(
+    "pattern, expected",
+    [
+        # "None" means all files, i.e. all match the given pattern
+        ("/", []),
+        ("/home", ["home"]),
+        ("/home///", ["home"]),
+        ("/./home", ["home"]),
+        ("/home/user", ["home/user"]),
+        ("/home/user2", ["home/user2"]),
+        ("/home/user/.bashrc", ["home/user/.bashrc"]),
+    ],
+)
 def test_patterns_full(pattern, expected):
-    files = ["home", "home/user", "home/user2", "home/user/.bashrc", ]
+    files = ["home", "home/user", "home/user2", "home/user/.bashrc"]
 
     check_patterns(files, PathFullPattern(pattern), expected)
 
 
-@pytest.mark.parametrize("pattern, expected", [
-    # "None" means all files, i.e. all match the given pattern
-    ("", []),
-    ("relative", []),
-    ("relative/path/", ["relative/path"]),
-    ("relative/path", ["relative/path"]),
-    ])
+@pytest.mark.parametrize(
+    "pattern, expected",
+    [
+        # "None" means all files, i.e. all match the given pattern
+        ("", []),
+        ("relative", []),
+        ("relative/path/", ["relative/path"]),
+        ("relative/path", ["relative/path"]),
+    ],
+)
 def test_patterns_full_relative(pattern, expected):
-    files = ["relative/path", "relative/path2", ]
+    files = ["relative/path", "relative/path2"]
 
     check_patterns(files, PathFullPattern(pattern), expected)
 
 
-@pytest.mark.parametrize("pattern, expected", [
-    # "None" means all files, i.e. all match the given pattern
-    ("/", None),
-    ("/./", None),
-    ("", []),
-    ("/home/u", []),
-    ("/home/user", ["home/user/.profile", "home/user/.bashrc"]),
-    ("/etc", ["etc/server/config", "etc/server/hosts"]),
-    ("///etc//////", ["etc/server/config", "etc/server/hosts"]),
-    ("/./home//..//home/user2", ["home/user2/.profile", "home/user2/public_html/index.html"]),
-    ("/srv", ["srv/messages", "srv/dmesg"]),
-    ])
+@pytest.mark.parametrize(
+    "pattern, expected",
+    [
+        # "None" means all files, i.e. all match the given pattern
+        ("/", None),
+        ("/./", None),
+        ("", []),
+        ("/home/u", []),
+        ("/home/user", ["home/user/.profile", "home/user/.bashrc"]),
+        ("/etc", ["etc/server/config", "etc/server/hosts"]),
+        ("///etc//////", ["etc/server/config", "etc/server/hosts"]),
+        ("/./home//..//home/user2", ["home/user2/.profile", "home/user2/public_html/index.html"]),
+        ("/srv", ["srv/messages", "srv/dmesg"]),
+    ],
+)
 def test_patterns_prefix(pattern, expected):
     files = [
-        "etc/server/config", "etc/server/hosts", "home", "home/user/.profile", "home/user/.bashrc",
-        "home/user2/.profile", "home/user2/public_html/index.html", "srv/messages", "srv/dmesg",
+        "etc/server/config",
+        "etc/server/hosts",
+        "home",
+        "home/user/.profile",
+        "home/user/.bashrc",
+        "home/user2/.profile",
+        "home/user2/public_html/index.html",
+        "srv/messages",
+        "srv/dmesg",
     ]
 
     check_patterns(files, PathPrefixPattern(pattern), expected)
 
 
-@pytest.mark.parametrize("pattern, expected", [
-    # "None" means all files, i.e. all match the given pattern
-    ("", []),
-    ("foo", []),
-    ("relative", ["relative/path1", "relative/two"]),
-    ("more", ["more/relative"]),
-    ])
+@pytest.mark.parametrize(
+    "pattern, expected",
+    [
+        # "None" means all files, i.e. all match the given pattern
+        ("", []),
+        ("foo", []),
+        ("relative", ["relative/path1", "relative/two"]),
+        ("more", ["more/relative"]),
+    ],
+)
 def test_patterns_prefix_relative(pattern, expected):
     files = ["relative/path1", "relative/two", "more/relative"]
 
     check_patterns(files, PathPrefixPattern(pattern), expected)
 
 
-@pytest.mark.parametrize("pattern, expected", [
-    # "None" means all files, i.e. all match the given pattern
-    ("/*", None),
-    ("/./*", None),
-    ("*", None),
-    ("*/*",
-     ["etc/server/config", "etc/server/hosts", "home/user/.profile", "home/user/.bashrc",
-      "home/user2/.profile", "home/user2/public_html/index.html", "srv/messages", "srv/dmesg",
-      "home/foo/.thumbnails", "home/foo/bar/.thumbnails"]),
-    ("*///*",
-     ["etc/server/config", "etc/server/hosts", "home/user/.profile", "home/user/.bashrc",
-      "home/user2/.profile", "home/user2/public_html/index.html", "srv/messages", "srv/dmesg",
-      "home/foo/.thumbnails", "home/foo/bar/.thumbnails"]),
-    ("/home/u", []),
-    ("/home/*",
-     ["home/user/.profile", "home/user/.bashrc", "home/user2/.profile", "home/user2/public_html/index.html",
-      "home/foo/.thumbnails", "home/foo/bar/.thumbnails"]),
-    ("/home/user/*", ["home/user/.profile", "home/user/.bashrc"]),
-    ("/etc/*", ["etc/server/config", "etc/server/hosts"]),
-    ("*/.pr????e", ["home/user/.profile", "home/user2/.profile"]),
-    ("///etc//////*", ["etc/server/config", "etc/server/hosts"]),
-    ("/./home//..//home/user2/*", ["home/user2/.profile", "home/user2/public_html/index.html"]),
-    ("/srv*", ["srv/messages", "srv/dmesg"]),
-    ("/home/*/.thumbnails", ["home/foo/.thumbnails", "home/foo/bar/.thumbnails"]),
-    ])
+@pytest.mark.parametrize(
+    "pattern, expected",
+    [
+        # "None" means all files, i.e. all match the given pattern
+        ("/*", None),
+        ("/./*", None),
+        ("*", None),
+        (
+            "*/*",
+            [
+                "etc/server/config",
+                "etc/server/hosts",
+                "home/user/.profile",
+                "home/user/.bashrc",
+                "home/user2/.profile",
+                "home/user2/public_html/index.html",
+                "srv/messages",
+                "srv/dmesg",
+                "home/foo/.thumbnails",
+                "home/foo/bar/.thumbnails",
+            ],
+        ),
+        (
+            "*///*",
+            [
+                "etc/server/config",
+                "etc/server/hosts",
+                "home/user/.profile",
+                "home/user/.bashrc",
+                "home/user2/.profile",
+                "home/user2/public_html/index.html",
+                "srv/messages",
+                "srv/dmesg",
+                "home/foo/.thumbnails",
+                "home/foo/bar/.thumbnails",
+            ],
+        ),
+        ("/home/u", []),
+        (
+            "/home/*",
+            [
+                "home/user/.profile",
+                "home/user/.bashrc",
+                "home/user2/.profile",
+                "home/user2/public_html/index.html",
+                "home/foo/.thumbnails",
+                "home/foo/bar/.thumbnails",
+            ],
+        ),
+        ("/home/user/*", ["home/user/.profile", "home/user/.bashrc"]),
+        ("/etc/*", ["etc/server/config", "etc/server/hosts"]),
+        ("*/.pr????e", ["home/user/.profile", "home/user2/.profile"]),
+        ("///etc//////*", ["etc/server/config", "etc/server/hosts"]),
+        ("/./home//..//home/user2/*", ["home/user2/.profile", "home/user2/public_html/index.html"]),
+        ("/srv*", ["srv/messages", "srv/dmesg"]),
+        ("/home/*/.thumbnails", ["home/foo/.thumbnails", "home/foo/bar/.thumbnails"]),
+    ],
+)
 def test_patterns_fnmatch(pattern, expected):
     files = [
-        "etc/server/config", "etc/server/hosts", "home", "home/user/.profile", "home/user/.bashrc",
-        "home/user2/.profile", "home/user2/public_html/index.html", "srv/messages", "srv/dmesg",
-        "home/foo/.thumbnails", "home/foo/bar/.thumbnails",
+        "etc/server/config",
+        "etc/server/hosts",
+        "home",
+        "home/user/.profile",
+        "home/user/.bashrc",
+        "home/user2/.profile",
+        "home/user2/public_html/index.html",
+        "srv/messages",
+        "srv/dmesg",
+        "home/foo/.thumbnails",
+        "home/foo/bar/.thumbnails",
     ]
 
     check_patterns(files, FnmatchPattern(pattern), expected)
 
 
-@pytest.mark.parametrize("pattern, expected", [
-    # "None" means all files, i.e. all match the given pattern
-    ("*", None),
-    ("**/*", None),
-    ("/**/*", None),
-    ("/./*", None),
-    ("*/*",
-     ["etc/server/config", "etc/server/hosts", "home/user/.profile", "home/user/.bashrc",
-      "home/user2/.profile", "home/user2/public_html/index.html", "srv/messages", "srv/dmesg",
-      "srv2/blafasel", "home/foo/.thumbnails", "home/foo/bar/.thumbnails"]),
-    ("*///*",
-     ["etc/server/config", "etc/server/hosts", "home/user/.profile", "home/user/.bashrc",
-      "home/user2/.profile", "home/user2/public_html/index.html", "srv/messages", "srv/dmesg",
-      "srv2/blafasel", "home/foo/.thumbnails", "home/foo/bar/.thumbnails"]),
-    ("/home/u", []),
-    ("/home/*",
-     ["home/user/.profile", "home/user/.bashrc", "home/user2/.profile", "home/user2/public_html/index.html",
-      "home/foo/.thumbnails", "home/foo/bar/.thumbnails"]),
-    ("/home/user/*", ["home/user/.profile", "home/user/.bashrc"]),
-    ("/etc/*/*", ["etc/server/config", "etc/server/hosts"]),
-    ("/etc/**/*", ["etc/server/config", "etc/server/hosts"]),
-    ("/etc/**/*/*", ["etc/server/config", "etc/server/hosts"]),
-    ("*/.pr????e", []),
-    ("**/.pr????e", ["home/user/.profile", "home/user2/.profile"]),
-    ("///etc//////*", ["etc/server/config", "etc/server/hosts"]),
-    ("/./home//..//home/user2/", ["home/user2/.profile", "home/user2/public_html/index.html"]),
-    ("/./home//..//home/user2/**/*", ["home/user2/.profile", "home/user2/public_html/index.html"]),
-    ("/srv*/", ["srv/messages", "srv/dmesg", "srv2/blafasel"]),
-    ("/srv*", ["srv", "srv/messages", "srv/dmesg", "srv2", "srv2/blafasel"]),
-    ("/srv/*", ["srv/messages", "srv/dmesg"]),
-    ("/srv2/**", ["srv2", "srv2/blafasel"]),
-    ("/srv2/**/", ["srv2/blafasel"]),
-    ("/home/*/.thumbnails", ["home/foo/.thumbnails"]),
-    ("/home/*/*/.thumbnails", ["home/foo/bar/.thumbnails"]),
-    ])
+@pytest.mark.parametrize(
+    "pattern, expected",
+    [
+        # "None" means all files, i.e. all match the given pattern
+        ("*", None),
+        ("**/*", None),
+        ("/**/*", None),
+        ("/./*", None),
+        (
+            "*/*",
+            [
+                "etc/server/config",
+                "etc/server/hosts",
+                "home/user/.profile",
+                "home/user/.bashrc",
+                "home/user2/.profile",
+                "home/user2/public_html/index.html",
+                "srv/messages",
+                "srv/dmesg",
+                "srv2/blafasel",
+                "home/foo/.thumbnails",
+                "home/foo/bar/.thumbnails",
+            ],
+        ),
+        (
+            "*///*",
+            [
+                "etc/server/config",
+                "etc/server/hosts",
+                "home/user/.profile",
+                "home/user/.bashrc",
+                "home/user2/.profile",
+                "home/user2/public_html/index.html",
+                "srv/messages",
+                "srv/dmesg",
+                "srv2/blafasel",
+                "home/foo/.thumbnails",
+                "home/foo/bar/.thumbnails",
+            ],
+        ),
+        ("/home/u", []),
+        (
+            "/home/*",
+            [
+                "home/user/.profile",
+                "home/user/.bashrc",
+                "home/user2/.profile",
+                "home/user2/public_html/index.html",
+                "home/foo/.thumbnails",
+                "home/foo/bar/.thumbnails",
+            ],
+        ),
+        ("/home/user/*", ["home/user/.profile", "home/user/.bashrc"]),
+        ("/etc/*/*", ["etc/server/config", "etc/server/hosts"]),
+        ("/etc/**/*", ["etc/server/config", "etc/server/hosts"]),
+        ("/etc/**/*/*", ["etc/server/config", "etc/server/hosts"]),
+        ("*/.pr????e", []),
+        ("**/.pr????e", ["home/user/.profile", "home/user2/.profile"]),
+        ("///etc//////*", ["etc/server/config", "etc/server/hosts"]),
+        ("/./home//..//home/user2/", ["home/user2/.profile", "home/user2/public_html/index.html"]),
+        ("/./home//..//home/user2/**/*", ["home/user2/.profile", "home/user2/public_html/index.html"]),
+        ("/srv*/", ["srv/messages", "srv/dmesg", "srv2/blafasel"]),
+        ("/srv*", ["srv", "srv/messages", "srv/dmesg", "srv2", "srv2/blafasel"]),
+        ("/srv/*", ["srv/messages", "srv/dmesg"]),
+        ("/srv2/**", ["srv2", "srv2/blafasel"]),
+        ("/srv2/**/", ["srv2/blafasel"]),
+        ("/home/*/.thumbnails", ["home/foo/.thumbnails"]),
+        ("/home/*/*/.thumbnails", ["home/foo/bar/.thumbnails"]),
+    ],
+)
 def test_patterns_shell(pattern, expected):
     files = [
-        "etc/server/config", "etc/server/hosts", "home", "home/user/.profile", "home/user/.bashrc",
-        "home/user2/.profile", "home/user2/public_html/index.html", "srv", "srv/messages", "srv/dmesg",
-        "srv2", "srv2/blafasel", "home/foo/.thumbnails", "home/foo/bar/.thumbnails",
+        "etc/server/config",
+        "etc/server/hosts",
+        "home",
+        "home/user/.profile",
+        "home/user/.bashrc",
+        "home/user2/.profile",
+        "home/user2/public_html/index.html",
+        "srv",
+        "srv/messages",
+        "srv/dmesg",
+        "srv2",
+        "srv2/blafasel",
+        "home/foo/.thumbnails",
+        "home/foo/bar/.thumbnails",
     ]
 
     check_patterns(files, ShellPattern(pattern), expected)
 
 
-@pytest.mark.parametrize("pattern, expected", [
-    # "None" means all files, i.e. all match the given pattern
-    ("", None),
-    (".*", None),
-    ("^/", None),
-    ("^abc$", []),
-    ("^[^/]", []),
-    ("^(?!/srv|/foo|/opt)",
-     ["/home", "/home/user/.profile", "/home/user/.bashrc", "/home/user2/.profile",
-      "/home/user2/public_html/index.html", "/home/foo/.thumbnails", "/home/foo/bar/.thumbnails", ]),
-    ])
+@pytest.mark.parametrize(
+    "pattern, expected",
+    [
+        # "None" means all files, i.e. all match the given pattern
+        ("", None),
+        (".*", None),
+        ("^/", None),
+        ("^abc$", []),
+        ("^[^/]", []),
+        (
+            "^(?!/srv|/foo|/opt)",
+            [
+                "/home",
+                "/home/user/.profile",
+                "/home/user/.bashrc",
+                "/home/user2/.profile",
+                "/home/user2/public_html/index.html",
+                "/home/foo/.thumbnails",
+                "/home/foo/bar/.thumbnails",
+            ],
+        ),
+    ],
+)
 def test_patterns_regex(pattern, expected):
     files = [
-        '/srv/data', '/foo/bar', '/home',
-        '/home/user/.profile', '/home/user/.bashrc',
-        '/home/user2/.profile', '/home/user2/public_html/index.html',
-        '/opt/log/messages.txt', '/opt/log/dmesg.txt',
-        "/home/foo/.thumbnails", "/home/foo/bar/.thumbnails",
+        "/srv/data",
+        "/foo/bar",
+        "/home",
+        "/home/user/.profile",
+        "/home/user/.bashrc",
+        "/home/user2/.profile",
+        "/home/user2/public_html/index.html",
+        "/opt/log/messages.txt",
+        "/opt/log/dmesg.txt",
+        "/home/foo/.thumbnails",
+        "/home/foo/bar/.thumbnails",
     ]
 
     obj = RegexPattern(pattern)
@@ -202,11 +325,12 @@ def use_normalized_unicode():
 
 
 def _make_test_patterns(pattern):
-    return [PathPrefixPattern(pattern),
-            FnmatchPattern(pattern),
-            RegexPattern(f"^{pattern}/foo$"),
-            ShellPattern(pattern),
-            ]
+    return [
+        PathPrefixPattern(pattern),
+        FnmatchPattern(pattern),
+        RegexPattern(f"^{pattern}/foo$"),
+        ShellPattern(pattern),
+    ]
 
 
 @pytest.mark.parametrize("pattern", _make_test_patterns("b\N{LATIN SMALL LETTER A WITH ACUTE}"))
@@ -227,51 +351,63 @@ def test_invalid_unicode_pattern(pattern):
     assert pattern.match(str(b"ba\x80/foo", "latin1"))
 
 
-@pytest.mark.parametrize("lines, expected", [
-    # "None" means all files, i.e. none excluded
-    ([], None),
-    (["# Comment only"], None),
-    (["*"], []),
-    (["# Comment",
-      "*/something00.txt",
-      "  *whitespace*  ",
-      # Whitespace before comment
-      " #/ws*",
-      # Empty line
-      "",
-      "# EOF"],
-     ["more/data", "home", " #/wsfoobar"]),
-    ([r"re:.*"], []),
-    ([r"re:\s"], ["data/something00.txt", "more/data", "home"]),
-    ([r"re:(.)(\1)"], ["more/data", "home", "\tstart/whitespace", "whitespace/end\t"]),
-    (["", "", "",
-      "# This is a test with mixed pattern styles",
-      # Case-insensitive pattern
-      r"re:(?i)BAR|ME$",
-      "",
-      "*whitespace*",
-      "fm:*/something00*"],
-     ["more/data"]),
-    ([r"  re:^\s  "], ["data/something00.txt", "more/data", "home", "whitespace/end\t"]),
-    ([r"  re:\s$  "], ["data/something00.txt", "more/data", "home", " #/wsfoobar", "\tstart/whitespace"]),
-    (["pp:./"], None),
-    # leading slash is removed
-    (["pp:/"], []),
-    (["pp:aaabbb"], None),
-    (["pp:/data", "pp: #/", "pp:\tstart", "pp:/whitespace"], ["more/data", "home"]),
-    (["/nomatch", "/more/*"],
-     ['data/something00.txt', 'home', ' #/wsfoobar', '\tstart/whitespace', 'whitespace/end\t']),
-    # the order of exclude patterns shouldn't matter
-    (["/more/*", "/nomatch"],
-     ['data/something00.txt', 'home', ' #/wsfoobar', '\tstart/whitespace', 'whitespace/end\t']),
-    ])
+@pytest.mark.parametrize(
+    "lines, expected",
+    [
+        # "None" means all files, i.e. none excluded
+        ([], None),
+        (["# Comment only"], None),
+        (["*"], []),
+        (
+            [
+                "# Comment",
+                "*/something00.txt",
+                "  *whitespace*  ",
+                # Whitespace before comment
+                " #/ws*",
+                # Empty line
+                "",
+                "# EOF",
+            ],
+            ["more/data", "home", " #/wsfoobar"],
+        ),
+        ([r"re:.*"], []),
+        ([r"re:\s"], ["data/something00.txt", "more/data", "home"]),
+        ([r"re:(.)(\1)"], ["more/data", "home", "\tstart/whitespace", "whitespace/end\t"]),
+        (
+            [
+                "",
+                "",
+                "",
+                "# This is a test with mixed pattern styles",
+                # Case-insensitive pattern
+                r"re:(?i)BAR|ME$",
+                "",
+                "*whitespace*",
+                "fm:*/something00*",
+            ],
+            ["more/data"],
+        ),
+        ([r"  re:^\s  "], ["data/something00.txt", "more/data", "home", "whitespace/end\t"]),
+        ([r"  re:\s$  "], ["data/something00.txt", "more/data", "home", " #/wsfoobar", "\tstart/whitespace"]),
+        (["pp:./"], None),
+        # leading slash is removed
+        (["pp:/"], []),
+        (["pp:aaabbb"], None),
+        (["pp:/data", "pp: #/", "pp:\tstart", "pp:/whitespace"], ["more/data", "home"]),
+        (
+            ["/nomatch", "/more/*"],
+            ["data/something00.txt", "home", " #/wsfoobar", "\tstart/whitespace", "whitespace/end\t"],
+        ),
+        # the order of exclude patterns shouldn't matter
+        (
+            ["/more/*", "/nomatch"],
+            ["data/something00.txt", "home", " #/wsfoobar", "\tstart/whitespace", "whitespace/end\t"],
+        ),
+    ],
+)
 def test_exclude_patterns_from_file(tmpdir, lines, expected):
-    files = [
-        'data/something00.txt', 'more/data', 'home',
-        ' #/wsfoobar',
-        '\tstart/whitespace',
-        'whitespace/end\t',
-    ]
+    files = ["data/something00.txt", "more/data", "home", " #/wsfoobar", "\tstart/whitespace", "whitespace/end\t"]
 
     def evaluate(filename):
         patterns = []
@@ -288,26 +424,26 @@ def test_exclude_patterns_from_file(tmpdir, lines, expected):
     assert evaluate(str(exclfile)) == (files if expected is None else expected)
 
 
-@pytest.mark.parametrize("lines, expected_roots, expected_numpatterns", [
-    # "None" means all files, i.e. none excluded
-    ([], [], 0),
-    (["# Comment only"], [], 0),
-    (["- *"], [], 1),
-    (["+fm:*/something00.txt",
-      "-/data"], [], 2),
-    (["R /"], ["/"], 0),
-    (["R /",
-      "# comment"], ["/"], 0),
-    (["# comment",
-      "- /data",
-      "R /home"], ["/home"], 1),
-])
+@pytest.mark.parametrize(
+    "lines, expected_roots, expected_numpatterns",
+    [
+        # "None" means all files, i.e. none excluded
+        ([], [], 0),
+        (["# Comment only"], [], 0),
+        (["- *"], [], 1),
+        (["+fm:*/something00.txt", "-/data"], [], 2),
+        (["R /"], ["/"], 0),
+        (["R /", "# comment"], ["/"], 0),
+        (["# comment", "- /data", "R /home"], ["/home"], 1),
+    ],
+)
 def test_load_patterns_from_file(tmpdir, lines, expected_roots, expected_numpatterns):
     def evaluate(filename):
         roots = []
         inclexclpatterns = []
         load_pattern_file(open(filename), roots, inclexclpatterns)
         return roots, len(inclexclpatterns)
+
     patternfile = tmpdir.join("patterns.txt")
 
     with patternfile.open("wt") as fh:
@@ -344,10 +480,9 @@ def test_switch_patterns_style():
     assert isinstance(patterns[5].val, ShellPattern)
 
 
-@pytest.mark.parametrize("lines", [
-    (["X /data"]),  # illegal pattern type prefix
-    (["/data"]),    # need a pattern type prefix
-])
+@pytest.mark.parametrize(
+    "lines", [(["X /data"]), (["/data"])]  # illegal pattern type prefix  # need a pattern type prefix
+)
 def test_load_invalid_patterns_from_file(tmpdir, lines):
     patternfile = tmpdir.join("patterns.txt")
     with patternfile.open("wt") as fh:
@@ -359,41 +494,47 @@ def test_load_invalid_patterns_from_file(tmpdir, lines):
         load_pattern_file(open(filename), roots, inclexclpatterns)
 
 
-@pytest.mark.parametrize("lines, expected", [
-    # "None" means all files, i.e. none excluded
-    ([], None),
-    (["# Comment only"], None),
-    (["- *"], []),
-    # default match type is sh: for patterns -> * doesn't match a /
-    (["-*/something0?.txt"],
-     ['data', 'data/subdir/something01.txt',
-      'home', 'home/leo', 'home/leo/t', 'home/other']),
-    (["-fm:*/something00.txt"],
-     ['data', 'data/subdir/something01.txt', 'home', 'home/leo', 'home/leo/t', 'home/other']),
-    (["-fm:*/something0?.txt"],
-     ["data", 'home', 'home/leo', 'home/leo/t', 'home/other']),
-    (["+/*/something0?.txt",
-      "-/data"],
-     ["data/something00.txt", 'home', 'home/leo', 'home/leo/t', 'home/other']),
-    (["+fm:*/something00.txt",
-      "-/data"],
-     ["data/something00.txt", 'home', 'home/leo', 'home/leo/t', 'home/other']),
-    # include /home/leo and exclude the rest of /home:
-    (["+/home/leo",
-      "-/home/*"],
-     ['data', 'data/something00.txt', 'data/subdir/something01.txt', 'home', 'home/leo', 'home/leo/t']),
-    # wrong order, /home/leo is already excluded by -/home/*:
-    (["-/home/*",
-      "+/home/leo"],
-     ['data', 'data/something00.txt', 'data/subdir/something01.txt', 'home']),
-    (["+fm:/home/leo",
-      "-/home/"],
-     ['data', 'data/something00.txt', 'data/subdir/something01.txt', 'home', 'home/leo', 'home/leo/t']),
-])
+@pytest.mark.parametrize(
+    "lines, expected",
+    [
+        # "None" means all files, i.e. none excluded
+        ([], None),
+        (["# Comment only"], None),
+        (["- *"], []),
+        # default match type is sh: for patterns -> * doesn't match a /
+        (
+            ["-*/something0?.txt"],
+            ["data", "data/subdir/something01.txt", "home", "home/leo", "home/leo/t", "home/other"],
+        ),
+        (
+            ["-fm:*/something00.txt"],
+            ["data", "data/subdir/something01.txt", "home", "home/leo", "home/leo/t", "home/other"],
+        ),
+        (["-fm:*/something0?.txt"], ["data", "home", "home/leo", "home/leo/t", "home/other"]),
+        (["+/*/something0?.txt", "-/data"], ["data/something00.txt", "home", "home/leo", "home/leo/t", "home/other"]),
+        (["+fm:*/something00.txt", "-/data"], ["data/something00.txt", "home", "home/leo", "home/leo/t", "home/other"]),
+        # include /home/leo and exclude the rest of /home:
+        (
+            ["+/home/leo", "-/home/*"],
+            ["data", "data/something00.txt", "data/subdir/something01.txt", "home", "home/leo", "home/leo/t"],
+        ),
+        # wrong order, /home/leo is already excluded by -/home/*:
+        (["-/home/*", "+/home/leo"], ["data", "data/something00.txt", "data/subdir/something01.txt", "home"]),
+        (
+            ["+fm:/home/leo", "-/home/"],
+            ["data", "data/something00.txt", "data/subdir/something01.txt", "home", "home/leo", "home/leo/t"],
+        ),
+    ],
+)
 def test_inclexcl_patterns_from_file(tmpdir, lines, expected):
     files = [
-        'data', 'data/something00.txt', 'data/subdir/something01.txt',
-        'home', 'home/leo', 'home/leo/t', 'home/other'
+        "data",
+        "data/something00.txt",
+        "data/subdir/something01.txt",
+        "home",
+        "home/leo",
+        "home/leo/t",
+        "home/other",
     ]
 
     def evaluate(filename):
@@ -412,37 +553,35 @@ def test_inclexcl_patterns_from_file(tmpdir, lines, expected):
     assert evaluate(str(patternfile)) == (files if expected is None else expected)
 
 
-@pytest.mark.parametrize("pattern, cls", [
-    ("", FnmatchPattern),
-
-    # Default style
-    ("*", FnmatchPattern),
-    ("/data/*", FnmatchPattern),
-
-    # fnmatch style
-    ("fm:", FnmatchPattern),
-    ("fm:*", FnmatchPattern),
-    ("fm:/data/*", FnmatchPattern),
-    ("fm:fm:/data/*", FnmatchPattern),
-
-    # Regular expression
-    ("re:", RegexPattern),
-    ("re:.*", RegexPattern),
-    ("re:^/something/", RegexPattern),
-    ("re:re:^/something/", RegexPattern),
-
-    # Path prefix
-    ("pp:", PathPrefixPattern),
-    ("pp:/", PathPrefixPattern),
-    ("pp:/data/", PathPrefixPattern),
-    ("pp:pp:/data/", PathPrefixPattern),
-
-    # Shell-pattern style
-    ("sh:", ShellPattern),
-    ("sh:*", ShellPattern),
-    ("sh:/data/*", ShellPattern),
-    ("sh:sh:/data/*", ShellPattern),
-    ])
+@pytest.mark.parametrize(
+    "pattern, cls",
+    [
+        ("", FnmatchPattern),
+        # Default style
+        ("*", FnmatchPattern),
+        ("/data/*", FnmatchPattern),
+        # fnmatch style
+        ("fm:", FnmatchPattern),
+        ("fm:*", FnmatchPattern),
+        ("fm:/data/*", FnmatchPattern),
+        ("fm:fm:/data/*", FnmatchPattern),
+        # Regular expression
+        ("re:", RegexPattern),
+        ("re:.*", RegexPattern),
+        ("re:^/something/", RegexPattern),
+        ("re:re:^/something/", RegexPattern),
+        # Path prefix
+        ("pp:", PathPrefixPattern),
+        ("pp:/", PathPrefixPattern),
+        ("pp:/data/", PathPrefixPattern),
+        ("pp:pp:/data/", PathPrefixPattern),
+        # Shell-pattern style
+        ("sh:", ShellPattern),
+        ("sh:*", ShellPattern),
+        ("sh:/data/*", ShellPattern),
+        ("sh:sh:/data/*", ShellPattern),
+    ],
+)
 def test_parse_pattern(pattern, cls):
     assert isinstance(parse_pattern(pattern), cls)
 
diff --git a/src/borg/testsuite/platform.py b/src/borg/testsuite/platform.py
index 35d444845..0b0f1d047 100644
--- a/src/borg/testsuite/platform.py
+++ b/src/borg/testsuite/platform.py
@@ -21,7 +21,9 @@ group:root:r--:0
 group:9999:r--:9999
 mask::rw-
 other::r--
-""".strip().encode('ascii')
+""".strip().encode(
+    "ascii"
+)
 
 DEFAULT_ACL = """
 user::rw-
@@ -32,18 +34,21 @@ group:root:r--:0
 group:8888:r--:8888
 mask::rw-
 other::r--
-""".strip().encode('ascii')
+""".strip().encode(
+    "ascii"
+)
 
 _acls_working = None
 
 
 def fakeroot_detected():
-    return 'FAKEROOTKEY' in os.environ
+    return "FAKEROOTKEY" in os.environ
 
 
 def user_exists(username):
     if not is_win32:
         import pwd
+
         try:
             pwd.getpwnam(username)
             return True
@@ -55,25 +60,24 @@ def user_exists(username):
 @functools.lru_cache
 def are_acls_working():
     with unopened_tempfile() as filepath:
-        open(filepath, 'w').close()
+        open(filepath, "w").close()
         try:
-            access = b'user::rw-\ngroup::r--\nmask::rw-\nother::---\nuser:root:rw-:9999\ngroup:root:rw-:9999\n'
-            acl = {'acl_access': access}
+            access = b"user::rw-\ngroup::r--\nmask::rw-\nother::---\nuser:root:rw-:9999\ngroup:root:rw-:9999\n"
+            acl = {"acl_access": access}
             acl_set(filepath, acl)
             read_acl = {}
             acl_get(filepath, read_acl, os.stat(filepath))
-            read_acl_access = read_acl.get('acl_access', None)
-            if read_acl_access and b'user::rw-' in read_acl_access:
+            read_acl_access = read_acl.get("acl_access", None)
+            if read_acl_access and b"user::rw-" in read_acl_access:
                 return True
         except PermissionError:
             pass
         return False
 
 
-@unittest.skipUnless(sys.platform.startswith('linux'), 'linux only test')
-@unittest.skipIf(fakeroot_detected(), 'not compatible with fakeroot')
+@unittest.skipUnless(sys.platform.startswith("linux"), "linux only test")
+@unittest.skipIf(fakeroot_detected(), "not compatible with fakeroot")
 class PlatformLinuxTestCase(BaseTestCase):
-
     def setUp(self):
         self.tmpdir = tempfile.mkdtemp()
 
@@ -86,72 +90,80 @@ class PlatformLinuxTestCase(BaseTestCase):
         return item
 
     def set_acl(self, path, access=None, default=None, numeric_ids=False):
-        item = {'acl_access': access, 'acl_default': default}
+        item = {"acl_access": access, "acl_default": default}
         acl_set(path, item, numeric_ids=numeric_ids)
 
-    @unittest.skipIf(not are_acls_working(), 'ACLs do not work')
+    @unittest.skipIf(not are_acls_working(), "ACLs do not work")
     def test_access_acl(self):
         file = tempfile.NamedTemporaryFile()
         self.assert_equal(self.get_acl(file.name), {})
-        self.set_acl(file.name, access=b'user::rw-\ngroup::r--\nmask::rw-\nother::---\nuser:root:rw-:9999\ngroup:root:rw-:9999\n', numeric_ids=False)
-        self.assert_in(b'user:root:rw-:0', self.get_acl(file.name)['acl_access'])
-        self.assert_in(b'group:root:rw-:0', self.get_acl(file.name)['acl_access'])
-        self.assert_in(b'user:0:rw-:0', self.get_acl(file.name, numeric_ids=True)['acl_access'])
+        self.set_acl(
+            file.name,
+            access=b"user::rw-\ngroup::r--\nmask::rw-\nother::---\nuser:root:rw-:9999\ngroup:root:rw-:9999\n",
+            numeric_ids=False,
+        )
+        self.assert_in(b"user:root:rw-:0", self.get_acl(file.name)["acl_access"])
+        self.assert_in(b"group:root:rw-:0", self.get_acl(file.name)["acl_access"])
+        self.assert_in(b"user:0:rw-:0", self.get_acl(file.name, numeric_ids=True)["acl_access"])
         file2 = tempfile.NamedTemporaryFile()
-        self.set_acl(file2.name, access=b'user::rw-\ngroup::r--\nmask::rw-\nother::---\nuser:root:rw-:9999\ngroup:root:rw-:9999\n', numeric_ids=True)
-        self.assert_in(b'user:9999:rw-:9999', self.get_acl(file2.name)['acl_access'])
-        self.assert_in(b'group:9999:rw-:9999', self.get_acl(file2.name)['acl_access'])
+        self.set_acl(
+            file2.name,
+            access=b"user::rw-\ngroup::r--\nmask::rw-\nother::---\nuser:root:rw-:9999\ngroup:root:rw-:9999\n",
+            numeric_ids=True,
+        )
+        self.assert_in(b"user:9999:rw-:9999", self.get_acl(file2.name)["acl_access"])
+        self.assert_in(b"group:9999:rw-:9999", self.get_acl(file2.name)["acl_access"])
 
-    @unittest.skipIf(not are_acls_working(), 'ACLs do not work')
+    @unittest.skipIf(not are_acls_working(), "ACLs do not work")
     def test_default_acl(self):
         self.assert_equal(self.get_acl(self.tmpdir), {})
         self.set_acl(self.tmpdir, access=ACCESS_ACL, default=DEFAULT_ACL)
-        self.assert_equal(self.get_acl(self.tmpdir)['acl_access'], ACCESS_ACL)
-        self.assert_equal(self.get_acl(self.tmpdir)['acl_default'], DEFAULT_ACL)
+        self.assert_equal(self.get_acl(self.tmpdir)["acl_access"], ACCESS_ACL)
+        self.assert_equal(self.get_acl(self.tmpdir)["acl_default"], DEFAULT_ACL)
 
-    @unittest.skipIf(not user_exists('übel'), 'requires übel user')
-    @unittest.skipIf(not are_acls_working(), 'ACLs do not work')
+    @unittest.skipIf(not user_exists("übel"), "requires übel user")
+    @unittest.skipIf(not are_acls_working(), "ACLs do not work")
     def test_non_ascii_acl(self):
         # Testing non-ascii ACL processing to see whether our code is robust.
         # I have no idea whether non-ascii ACLs are allowed by the standard,
         # but in practice they seem to be out there and must not make our code explode.
         file = tempfile.NamedTemporaryFile()
         self.assert_equal(self.get_acl(file.name), {})
-        nothing_special = b'user::rw-\ngroup::r--\nmask::rw-\nother::---\n'
+        nothing_special = b"user::rw-\ngroup::r--\nmask::rw-\nother::---\n"
         # TODO: can this be tested without having an existing system user übel with uid 666 gid 666?
-        user_entry = 'user:übel:rw-:666'.encode()
-        user_entry_numeric = b'user:666:rw-:666'
-        group_entry = 'group:übel:rw-:666'.encode()
-        group_entry_numeric = b'group:666:rw-:666'
-        acl = b'\n'.join([nothing_special, user_entry, group_entry])
+        user_entry = "user:übel:rw-:666".encode()
+        user_entry_numeric = b"user:666:rw-:666"
+        group_entry = "group:übel:rw-:666".encode()
+        group_entry_numeric = b"group:666:rw-:666"
+        acl = b"\n".join([nothing_special, user_entry, group_entry])
         self.set_acl(file.name, access=acl, numeric_ids=False)
-        acl_access = self.get_acl(file.name, numeric_ids=False)['acl_access']
+        acl_access = self.get_acl(file.name, numeric_ids=False)["acl_access"]
         self.assert_in(user_entry, acl_access)
         self.assert_in(group_entry, acl_access)
-        acl_access_numeric = self.get_acl(file.name, numeric_ids=True)['acl_access']
+        acl_access_numeric = self.get_acl(file.name, numeric_ids=True)["acl_access"]
         self.assert_in(user_entry_numeric, acl_access_numeric)
         self.assert_in(group_entry_numeric, acl_access_numeric)
         file2 = tempfile.NamedTemporaryFile()
         self.set_acl(file2.name, access=acl, numeric_ids=True)
-        acl_access = self.get_acl(file2.name, numeric_ids=False)['acl_access']
+        acl_access = self.get_acl(file2.name, numeric_ids=False)["acl_access"]
         self.assert_in(user_entry, acl_access)
         self.assert_in(group_entry, acl_access)
-        acl_access_numeric = self.get_acl(file.name, numeric_ids=True)['acl_access']
+        acl_access_numeric = self.get_acl(file.name, numeric_ids=True)["acl_access"]
         self.assert_in(user_entry_numeric, acl_access_numeric)
         self.assert_in(group_entry_numeric, acl_access_numeric)
 
     def test_utils(self):
         from ..platform.linux import acl_use_local_uid_gid
-        self.assert_equal(acl_use_local_uid_gid(b'user:nonexistent1234:rw-:1234'), b'user:1234:rw-')
-        self.assert_equal(acl_use_local_uid_gid(b'group:nonexistent1234:rw-:1234'), b'group:1234:rw-')
-        self.assert_equal(acl_use_local_uid_gid(b'user:root:rw-:0'), b'user:0:rw-')
-        self.assert_equal(acl_use_local_uid_gid(b'group:root:rw-:0'), b'group:0:rw-')
+
+        self.assert_equal(acl_use_local_uid_gid(b"user:nonexistent1234:rw-:1234"), b"user:1234:rw-")
+        self.assert_equal(acl_use_local_uid_gid(b"group:nonexistent1234:rw-:1234"), b"group:1234:rw-")
+        self.assert_equal(acl_use_local_uid_gid(b"user:root:rw-:0"), b"user:0:rw-")
+        self.assert_equal(acl_use_local_uid_gid(b"group:root:rw-:0"), b"group:0:rw-")
 
 
-@unittest.skipUnless(sys.platform.startswith('darwin'), 'OS X only test')
-@unittest.skipIf(fakeroot_detected(), 'not compatible with fakeroot')
+@unittest.skipUnless(sys.platform.startswith("darwin"), "OS X only test")
+@unittest.skipIf(fakeroot_detected(), "not compatible with fakeroot")
 class PlatformDarwinTestCase(BaseTestCase):
-
     def setUp(self):
         self.tmpdir = tempfile.mkdtemp()
 
@@ -164,25 +176,41 @@ class PlatformDarwinTestCase(BaseTestCase):
         return item
 
     def set_acl(self, path, acl, numeric_ids=False):
-        item = {'acl_extended': acl}
+        item = {"acl_extended": acl}
         acl_set(path, item, numeric_ids=numeric_ids)
 
-    @unittest.skipIf(not are_acls_working(), 'ACLs do not work')
+    @unittest.skipIf(not are_acls_working(), "ACLs do not work")
     def test_access_acl(self):
         file = tempfile.NamedTemporaryFile()
         file2 = tempfile.NamedTemporaryFile()
         self.assert_equal(self.get_acl(file.name), {})
-        self.set_acl(file.name, b'!#acl 1\ngroup:ABCDEFAB-CDEF-ABCD-EFAB-CDEF00000000:staff:0:allow:read\nuser:FFFFEEEE-DDDD-CCCC-BBBB-AAAA00000000:root:0:allow:read\n', numeric_ids=False)
-        self.assert_in(b'group:ABCDEFAB-CDEF-ABCD-EFAB-CDEF00000014:staff:20:allow:read', self.get_acl(file.name)['acl_extended'])
-        self.assert_in(b'user:FFFFEEEE-DDDD-CCCC-BBBB-AAAA00000000:root:0:allow:read', self.get_acl(file.name)['acl_extended'])
-        self.set_acl(file2.name, b'!#acl 1\ngroup:ABCDEFAB-CDEF-ABCD-EFAB-CDEF00000000:staff:0:allow:read\nuser:FFFFEEEE-DDDD-CCCC-BBBB-AAAA00000000:root:0:allow:read\n', numeric_ids=True)
-        self.assert_in(b'group:ABCDEFAB-CDEF-ABCD-EFAB-CDEF00000000:wheel:0:allow:read', self.get_acl(file2.name)['acl_extended'])
-        self.assert_in(b'group:ABCDEFAB-CDEF-ABCD-EFAB-CDEF00000000::0:allow:read', self.get_acl(file2.name, numeric_ids=True)['acl_extended'])
+        self.set_acl(
+            file.name,
+            b"!#acl 1\ngroup:ABCDEFAB-CDEF-ABCD-EFAB-CDEF00000000:staff:0:allow:read\nuser:FFFFEEEE-DDDD-CCCC-BBBB-AAAA00000000:root:0:allow:read\n",
+            numeric_ids=False,
+        )
+        self.assert_in(
+            b"group:ABCDEFAB-CDEF-ABCD-EFAB-CDEF00000014:staff:20:allow:read", self.get_acl(file.name)["acl_extended"]
+        )
+        self.assert_in(
+            b"user:FFFFEEEE-DDDD-CCCC-BBBB-AAAA00000000:root:0:allow:read", self.get_acl(file.name)["acl_extended"]
+        )
+        self.set_acl(
+            file2.name,
+            b"!#acl 1\ngroup:ABCDEFAB-CDEF-ABCD-EFAB-CDEF00000000:staff:0:allow:read\nuser:FFFFEEEE-DDDD-CCCC-BBBB-AAAA00000000:root:0:allow:read\n",
+            numeric_ids=True,
+        )
+        self.assert_in(
+            b"group:ABCDEFAB-CDEF-ABCD-EFAB-CDEF00000000:wheel:0:allow:read", self.get_acl(file2.name)["acl_extended"]
+        )
+        self.assert_in(
+            b"group:ABCDEFAB-CDEF-ABCD-EFAB-CDEF00000000::0:allow:read",
+            self.get_acl(file2.name, numeric_ids=True)["acl_extended"],
+        )
 
 
-@unittest.skipUnless(sys.platform.startswith(('linux', 'freebsd', 'darwin')), 'POSIX only tests')
+@unittest.skipUnless(sys.platform.startswith(("linux", "freebsd", "darwin")), "POSIX only tests")
 class PlatformPosixTestCase(BaseTestCase):
-
     def test_swidth_ascii(self):
         self.assert_equal(swidth("borg"), 4)
 
@@ -197,7 +225,7 @@ def test_process_alive(free_pid):
     id = get_process_id()
     assert process_alive(*id)
     host, pid, tid = id
-    assert process_alive(host + 'abc', pid, tid)
+    assert process_alive(host + "abc", pid, tid)
     assert process_alive(host, pid, tid + 1)
     assert not process_alive(host, free_pid, tid)
 
diff --git a/src/borg/testsuite/remote.py b/src/borg/testsuite/remote.py
index fe94dc414..125cd9260 100644
--- a/src/borg/testsuite/remote.py
+++ b/src/borg/testsuite/remote.py
@@ -72,10 +72,10 @@ class TestSleepingBandwidthLimiter:
 class TestRepositoryCache:
     @pytest.fixture
     def repository(self, tmpdir):
-        self.repository_location = os.path.join(str(tmpdir), 'repository')
+        self.repository_location = os.path.join(str(tmpdir), "repository")
         with Repository(self.repository_location, exclusive=True, create=True) as repository:
-            repository.put(H(1), b'1234')
-            repository.put(H(2), b'5678')
+            repository.put(H(1), b"1234")
+            repository.put(H(2), b"5678")
             repository.put(H(3), bytes(100))
             yield repository
 
@@ -85,19 +85,19 @@ class TestRepositoryCache:
 
     def test_simple(self, cache: RepositoryCache):
         # Single get()s are not cached, since they are used for unique objects like archives.
-        assert cache.get(H(1)) == b'1234'
+        assert cache.get(H(1)) == b"1234"
         assert cache.misses == 1
         assert cache.hits == 0
 
-        assert list(cache.get_many([H(1)])) == [b'1234']
+        assert list(cache.get_many([H(1)])) == [b"1234"]
         assert cache.misses == 2
         assert cache.hits == 0
 
-        assert list(cache.get_many([H(1)])) == [b'1234']
+        assert list(cache.get_many([H(1)])) == [b"1234"]
         assert cache.misses == 2
         assert cache.hits == 1
 
-        assert cache.get(H(1)) == b'1234'
+        assert cache.get(H(1)) == b"1234"
         assert cache.misses == 2
         assert cache.hits == 2
 
@@ -105,11 +105,11 @@ class TestRepositoryCache:
         def query_size_limit():
             cache.size_limit = 0
 
-        assert list(cache.get_many([H(1), H(2)])) == [b'1234', b'5678']
+        assert list(cache.get_many([H(1), H(2)])) == [b"1234", b"5678"]
         assert cache.misses == 2
         assert cache.evictions == 0
         iterator = cache.get_many([H(1), H(3), H(2)])
-        assert next(iterator) == b'1234'
+        assert next(iterator) == b"1234"
 
         # Force cache to back off
         qsl = cache.query_size_limit
@@ -124,7 +124,7 @@ class TestRepositoryCache:
         assert cache.slow_misses == 0
         # Since H(2) was in the cache when we called get_many(), but has
         # been evicted during iterating the generator, it will be a slow miss.
-        assert next(iterator) == b'5678'
+        assert next(iterator) == b"5678"
         assert cache.slow_misses == 1
 
     def test_enospc(self, cache: RepositoryCache):
@@ -139,16 +139,16 @@ class TestRepositoryCache:
                 pass
 
             def write(self, data):
-                raise OSError(errno.ENOSPC, 'foo')
+                raise OSError(errno.ENOSPC, "foo")
 
             def truncate(self, n=None):
                 pass
 
         iterator = cache.get_many([H(1), H(2), H(3)])
-        assert next(iterator) == b'1234'
+        assert next(iterator) == b"1234"
 
-        with patch('builtins.open', enospc_open):
-            assert next(iterator) == b'5678'
+        with patch("builtins.open", enospc_open):
+            assert next(iterator) == b"5678"
             assert cache.enospc == 1
             # We didn't patch query_size_limit which would set size_limit to some low
             # value, so nothing was actually evicted.
@@ -158,9 +158,9 @@ class TestRepositoryCache:
 
     @pytest.fixture
     def key(self, repository, monkeypatch):
-        monkeypatch.setenv('BORG_PASSPHRASE', 'test')
+        monkeypatch.setenv("BORG_PASSPHRASE", "test")
         key = PlaintextKey.create(repository, TestKey.MockArgs())
-        key.compressor = CompressionSpec('none').compressor
+        key.compressor = CompressionSpec("none").compressor
         return key
 
     def _put_encrypted_object(self, key, repository, data):
@@ -170,11 +170,11 @@ class TestRepositoryCache:
 
     @pytest.fixture
     def H1(self, key, repository):
-        return self._put_encrypted_object(key, repository, b'1234')
+        return self._put_encrypted_object(key, repository, b"1234")
 
     @pytest.fixture
     def H2(self, key, repository):
-        return self._put_encrypted_object(key, repository, b'5678')
+        return self._put_encrypted_object(key, repository, b"5678")
 
     @pytest.fixture
     def H3(self, key, repository):
@@ -188,14 +188,14 @@ class TestRepositoryCache:
         list(decrypted_cache.get_many([H1, H2, H3]))
 
         iterator = decrypted_cache.get_many([H1, H2, H3])
-        assert next(iterator) == (7, b'1234')
+        assert next(iterator) == (7, b"1234")
 
-        with open(decrypted_cache.key_filename(H2), 'a+b') as fd:
+        with open(decrypted_cache.key_filename(H2), "a+b") as fd:
             fd.seek(-1, io.SEEK_END)
-            corrupted = (int.from_bytes(fd.read(), 'little') ^ 2).to_bytes(1, 'little')
+            corrupted = (int.from_bytes(fd.read(), "little") ^ 2).to_bytes(1, "little")
             fd.seek(-1, io.SEEK_END)
             fd.write(corrupted)
             fd.truncate()
 
         with pytest.raises(IntegrityError):
-            assert next(iterator) == (7, b'5678')
+            assert next(iterator) == (7, b"5678")
diff --git a/src/borg/testsuite/repository.py b/src/borg/testsuite/repository.py
index 9248e5d8f..9c2ffefe4 100644
--- a/src/borg/testsuite/repository.py
+++ b/src/borg/testsuite/repository.py
@@ -29,7 +29,7 @@ class RepositoryTestCaseBase(BaseTestCase):
     def open(self, create=False, exclusive=UNSPECIFIED):
         if exclusive is UNSPECIFIED:
             exclusive = self.exclusive
-        return Repository(os.path.join(self.tmppath, 'repository'), exclusive=exclusive, create=create)
+        return Repository(os.path.join(self.tmppath, "repository"), exclusive=exclusive, create=create)
 
     def setUp(self):
         self.tmppath = tempfile.mkdtemp()
@@ -46,19 +46,19 @@ class RepositoryTestCaseBase(BaseTestCase):
         self.repository = self.open(exclusive=exclusive)
 
     def add_keys(self):
-        self.repository.put(H(0), b'foo')
-        self.repository.put(H(1), b'bar')
-        self.repository.put(H(3), b'bar')
+        self.repository.put(H(0), b"foo")
+        self.repository.put(H(1), b"bar")
+        self.repository.put(H(3), b"bar")
         self.repository.commit(compact=False)
-        self.repository.put(H(1), b'bar2')
-        self.repository.put(H(2), b'boo')
+        self.repository.put(H(1), b"bar2")
+        self.repository.put(H(2), b"boo")
         self.repository.delete(H(3))
 
     def repo_dump(self, label=None):
-        label = label + ': ' if label is not None else ''
+        label = label + ": " if label is not None else ""
         H_trans = {H(i): i for i in range(10)}
         H_trans[None] = -1  # key == None appears in commits
-        tag_trans = {TAG_PUT2: 'put2', TAG_PUT: 'put', TAG_DELETE: 'del', TAG_COMMIT: 'comm'}
+        tag_trans = {TAG_PUT2: "put2", TAG_PUT: "put", TAG_DELETE: "del", TAG_COMMIT: "comm"}
         for segment, fn in self.repository.io.segment_iterator():
             for tag, key, offset, size in self.repository.io.iter_objects(segment):
                 print("%s%s H(%d) -> %s[%d..+%d]" % (label, tag_trans[tag], H_trans[key], fn, offset, size))
@@ -66,12 +66,11 @@ class RepositoryTestCaseBase(BaseTestCase):
 
 
 class RepositoryTestCase(RepositoryTestCaseBase):
-
     def test1(self):
         for x in range(100):
-            self.repository.put(H(x), b'SOMEDATA')
+            self.repository.put(H(x), b"SOMEDATA")
         key50 = H(50)
-        self.assert_equal(self.repository.get(key50), b'SOMEDATA')
+        self.assert_equal(self.repository.get(key50), b"SOMEDATA")
         self.repository.delete(key50)
         self.assert_raises(Repository.ObjectNotFound, lambda: self.repository.get(key50))
         self.repository.commit(compact=False)
@@ -81,59 +80,55 @@ class RepositoryTestCase(RepositoryTestCaseBase):
             for x in range(100):
                 if x == 50:
                     continue
-                self.assert_equal(repository2.get(H(x)), b'SOMEDATA')
+                self.assert_equal(repository2.get(H(x)), b"SOMEDATA")
 
     def test2(self):
-        """Test multiple sequential transactions
-        """
-        self.repository.put(H(0), b'foo')
-        self.repository.put(H(1), b'foo')
+        """Test multiple sequential transactions"""
+        self.repository.put(H(0), b"foo")
+        self.repository.put(H(1), b"foo")
         self.repository.commit(compact=False)
         self.repository.delete(H(0))
-        self.repository.put(H(1), b'bar')
+        self.repository.put(H(1), b"bar")
         self.repository.commit(compact=False)
-        self.assert_equal(self.repository.get(H(1)), b'bar')
+        self.assert_equal(self.repository.get(H(1)), b"bar")
 
     def test_consistency(self):
-        """Test cache consistency
-        """
-        self.repository.put(H(0), b'foo')
-        self.assert_equal(self.repository.get(H(0)), b'foo')
-        self.repository.put(H(0), b'foo2')
-        self.assert_equal(self.repository.get(H(0)), b'foo2')
-        self.repository.put(H(0), b'bar')
-        self.assert_equal(self.repository.get(H(0)), b'bar')
+        """Test cache consistency"""
+        self.repository.put(H(0), b"foo")
+        self.assert_equal(self.repository.get(H(0)), b"foo")
+        self.repository.put(H(0), b"foo2")
+        self.assert_equal(self.repository.get(H(0)), b"foo2")
+        self.repository.put(H(0), b"bar")
+        self.assert_equal(self.repository.get(H(0)), b"bar")
         self.repository.delete(H(0))
         self.assert_raises(Repository.ObjectNotFound, lambda: self.repository.get(H(0)))
 
     def test_consistency2(self):
-        """Test cache consistency2
-        """
-        self.repository.put(H(0), b'foo')
-        self.assert_equal(self.repository.get(H(0)), b'foo')
+        """Test cache consistency2"""
+        self.repository.put(H(0), b"foo")
+        self.assert_equal(self.repository.get(H(0)), b"foo")
         self.repository.commit(compact=False)
-        self.repository.put(H(0), b'foo2')
-        self.assert_equal(self.repository.get(H(0)), b'foo2')
+        self.repository.put(H(0), b"foo2")
+        self.assert_equal(self.repository.get(H(0)), b"foo2")
         self.repository.rollback()
-        self.assert_equal(self.repository.get(H(0)), b'foo')
+        self.assert_equal(self.repository.get(H(0)), b"foo")
 
     def test_overwrite_in_same_transaction(self):
-        """Test cache consistency2
-        """
-        self.repository.put(H(0), b'foo')
-        self.repository.put(H(0), b'foo2')
+        """Test cache consistency2"""
+        self.repository.put(H(0), b"foo")
+        self.repository.put(H(0), b"foo2")
         self.repository.commit(compact=False)
-        self.assert_equal(self.repository.get(H(0)), b'foo2')
+        self.assert_equal(self.repository.get(H(0)), b"foo2")
 
     def test_single_kind_transactions(self):
         # put
-        self.repository.put(H(0), b'foo')
+        self.repository.put(H(0), b"foo")
         self.repository.commit(compact=False)
         self.repository.close()
         # replace
         self.repository = self.open()
         with self.repository:
-            self.repository.put(H(0), b'bar')
+            self.repository.put(H(0), b"bar")
             self.repository.commit(compact=False)
         # delete
         self.repository = self.open()
@@ -143,7 +138,7 @@ class RepositoryTestCase(RepositoryTestCaseBase):
 
     def test_list(self):
         for x in range(100):
-            self.repository.put(H(x), b'SOMEDATA')
+            self.repository.put(H(x), b"SOMEDATA")
         self.repository.commit(compact=False)
         all = self.repository.list()
         self.assert_equal(len(all), 100)
@@ -157,7 +152,7 @@ class RepositoryTestCase(RepositoryTestCaseBase):
 
     def test_scan(self):
         for x in range(100):
-            self.repository.put(H(x), b'SOMEDATA')
+            self.repository.put(H(x), b"SOMEDATA")
         self.repository.commit(compact=False)
         all = self.repository.scan()
         assert len(all) == 100
@@ -173,11 +168,10 @@ class RepositoryTestCase(RepositoryTestCaseBase):
             assert all[x] == H(x)
 
     def test_max_data_size(self):
-        max_data = b'x' * MAX_DATA_SIZE
+        max_data = b"x" * MAX_DATA_SIZE
         self.repository.put(H(0), max_data)
         self.assert_equal(self.repository.get(H(0)), max_data)
-        self.assert_raises(IntegrityError,
-                           lambda: self.repository.put(H(1), max_data + b'x'))
+        self.assert_raises(IntegrityError, lambda: self.repository.put(H(1), max_data + b"x"))
 
 
 class LocalRepositoryTestCase(RepositoryTestCaseBase):
@@ -194,21 +188,21 @@ class LocalRepositoryTestCase(RepositoryTestCaseBase):
         assert self.repository.compact[0] == 41 + 8 + 9
 
     def test_sparse1(self):
-        self.repository.put(H(0), b'foo')
-        self.repository.put(H(1), b'123456789')
+        self.repository.put(H(0), b"foo")
+        self.repository.put(H(1), b"123456789")
         self.repository.commit(compact=False)
-        self.repository.put(H(1), b'bar')
+        self.repository.put(H(1), b"bar")
         self._assert_sparse()
 
     def test_sparse2(self):
-        self.repository.put(H(0), b'foo')
-        self.repository.put(H(1), b'123456789')
+        self.repository.put(H(0), b"foo")
+        self.repository.put(H(1), b"123456789")
         self.repository.commit(compact=False)
         self.repository.delete(H(1))
         self._assert_sparse()
 
     def test_sparse_delete(self):
-        self.repository.put(H(0), b'1245')
+        self.repository.put(H(0), b"1245")
         self.repository.delete(H(0))
         self.repository.io._write_fd.sync()
 
@@ -224,27 +218,26 @@ class LocalRepositoryTestCase(RepositoryTestCaseBase):
     def test_uncommitted_garbage(self):
         # uncommitted garbage should be no problem, it is cleaned up automatically.
         # we just have to be careful with invalidation of cached FDs in LoggedIO.
-        self.repository.put(H(0), b'foo')
+        self.repository.put(H(0), b"foo")
         self.repository.commit(compact=False)
         # write some crap to a uncommitted segment file
         last_segment = self.repository.io.get_latest_segment()
-        with open(self.repository.io.segment_filename(last_segment + 1), 'wb') as f:
-            f.write(MAGIC + b'crapcrapcrap')
+        with open(self.repository.io.segment_filename(last_segment + 1), "wb") as f:
+            f.write(MAGIC + b"crapcrapcrap")
         self.repository.close()
         # usually, opening the repo and starting a transaction should trigger a cleanup.
         self.repository = self.open()
         with self.repository:
-            self.repository.put(H(0), b'bar')  # this may trigger compact_segments()
+            self.repository.put(H(0), b"bar")  # this may trigger compact_segments()
             self.repository.commit(compact=True)
         # the point here is that nothing blows up with an exception.
 
 
 class RepositoryCommitTestCase(RepositoryTestCaseBase):
-
     def test_replay_of_missing_index(self):
         self.add_keys()
         for name in os.listdir(self.repository.path):
-            if name.startswith('index.'):
+            if name.startswith("index."):
                 os.unlink(os.path.join(self.repository.path, name))
         self.reopen()
         with self.repository:
@@ -278,9 +271,9 @@ class RepositoryCommitTestCase(RepositoryTestCaseBase):
     def test_replay_lock_upgrade_old(self):
         self.add_keys()
         for name in os.listdir(self.repository.path):
-            if name.startswith('index.'):
+            if name.startswith("index."):
                 os.unlink(os.path.join(self.repository.path, name))
-        with patch.object(Lock, 'upgrade', side_effect=LockFailed) as upgrade:
+        with patch.object(Lock, "upgrade", side_effect=LockFailed) as upgrade:
             self.reopen(exclusive=None)  # simulate old client that always does lock upgrades
             with self.repository:
                 # the repo is only locked by a shared read lock, but to replay segments,
@@ -291,9 +284,9 @@ class RepositoryCommitTestCase(RepositoryTestCaseBase):
     def test_replay_lock_upgrade(self):
         self.add_keys()
         for name in os.listdir(self.repository.path):
-            if name.startswith('index.'):
+            if name.startswith("index."):
                 os.unlink(os.path.join(self.repository.path, name))
-        with patch.object(Lock, 'upgrade', side_effect=LockFailed) as upgrade:
+        with patch.object(Lock, "upgrade", side_effect=LockFailed) as upgrade:
             self.reopen(exclusive=False)  # current client usually does not do lock upgrade, except for replay
             with self.repository:
                 # the repo is only locked by a shared read lock, but to replay segments,
@@ -322,13 +315,13 @@ class RepositoryCommitTestCase(RepositoryTestCaseBase):
             assert not io.is_committed_segment(io.get_latest_segment())
 
     def test_moved_deletes_are_tracked(self):
-        self.repository.put(H(1), b'1')
-        self.repository.put(H(2), b'2')
+        self.repository.put(H(1), b"1")
+        self.repository.put(H(2), b"2")
         self.repository.commit(compact=False)
-        self.repo_dump('p1 p2 c')
+        self.repo_dump("p1 p2 c")
         self.repository.delete(H(1))
         self.repository.commit(compact=True)
-        self.repo_dump('d1 cc')
+        self.repo_dump("d1 cc")
         last_segment = self.repository.io.get_latest_segment() - 1
         num_deletes = 0
         for tag, key, offset, size in self.repository.io.iter_objects(last_segment):
@@ -337,9 +330,9 @@ class RepositoryCommitTestCase(RepositoryTestCaseBase):
                 num_deletes += 1
         assert num_deletes == 1
         assert last_segment in self.repository.compact
-        self.repository.put(H(3), b'3')
+        self.repository.put(H(3), b"3")
         self.repository.commit(compact=True)
-        self.repo_dump('p3 cc')
+        self.repo_dump("p3 cc")
         assert last_segment not in self.repository.compact
         assert not self.repository.io.segment_exists(last_segment)
         for segment, _ in self.repository.io.segment_iterator():
@@ -352,7 +345,7 @@ class RepositoryCommitTestCase(RepositoryTestCaseBase):
 
     def test_shadowed_entries_are_preserved(self):
         get_latest_segment = self.repository.io.get_latest_segment
-        self.repository.put(H(1), b'1')
+        self.repository.put(H(1), b"1")
         # This is the segment with our original PUT of interest
         put_segment = get_latest_segment()
         self.repository.commit(compact=False)
@@ -360,7 +353,7 @@ class RepositoryCommitTestCase(RepositoryTestCaseBase):
         # We now delete H(1), and force this segment to not be compacted, which can happen
         # if it's not sparse enough (symbolized by H(2) here).
         self.repository.delete(H(1))
-        self.repository.put(H(2), b'1')
+        self.repository.put(H(2), b"1")
         delete_segment = get_latest_segment()
 
         # We pretend these are mostly dense (not sparse) and won't be compacted
@@ -380,33 +373,33 @@ class RepositoryCommitTestCase(RepositoryTestCaseBase):
         # Basic case, since the index survived this must be ok
         assert H(1) not in self.repository
         # Nuke index, force replay
-        os.unlink(os.path.join(self.repository.path, 'index.%d' % get_latest_segment()))
+        os.unlink(os.path.join(self.repository.path, "index.%d" % get_latest_segment()))
         # Must not reappear
         assert H(1) not in self.repository
 
     def test_shadow_index_rollback(self):
-        self.repository.put(H(1), b'1')
+        self.repository.put(H(1), b"1")
         self.repository.delete(H(1))
         assert self.repository.shadow_index[H(1)] == [0]
         self.repository.commit(compact=True)
-        self.repo_dump('p1 d1 cc')
+        self.repo_dump("p1 d1 cc")
         # note how an empty list means that nothing is shadowed for sure
         assert self.repository.shadow_index[H(1)] == []  # because the delete is considered unstable
-        self.repository.put(H(1), b'1')
+        self.repository.put(H(1), b"1")
         self.repository.delete(H(1))
-        self.repo_dump('p1 d1')
+        self.repo_dump("p1 d1")
         # 0 put/delete; 1 commit; 2 compacted; 3 commit; 4 put/delete
         assert self.repository.shadow_index[H(1)] == [4]
         self.repository.rollback()
-        self.repo_dump('r')
-        self.repository.put(H(2), b'1')
+        self.repo_dump("r")
+        self.repository.put(H(2), b"1")
         # After the rollback segment 4 shouldn't be considered anymore
         assert self.repository.shadow_index[H(1)] == []  # because the delete is considered unstable
 
 
 class RepositoryAppendOnlyTestCase(RepositoryTestCaseBase):
     def open(self, create=False):
-        return Repository(os.path.join(self.tmppath, 'repository'), exclusive=True, create=create, append_only=True)
+        return Repository(os.path.join(self.tmppath, "repository"), exclusive=True, create=create, append_only=True)
 
     def test_destroy_append_only(self):
         # Can't destroy append only repo (via the API)
@@ -417,19 +410,20 @@ class RepositoryAppendOnlyTestCase(RepositoryTestCaseBase):
     def test_append_only(self):
         def segments_in_repository():
             return len(list(self.repository.io.segment_iterator()))
-        self.repository.put(H(0), b'foo')
+
+        self.repository.put(H(0), b"foo")
         self.repository.commit(compact=False)
 
         self.repository.append_only = False
         assert segments_in_repository() == 2
-        self.repository.put(H(0), b'foo')
+        self.repository.put(H(0), b"foo")
         self.repository.commit(compact=True)
         # normal: compact squashes the data together, only one segment
         assert segments_in_repository() == 2
 
         self.repository.append_only = True
         assert segments_in_repository() == 2
-        self.repository.put(H(0), b'foo')
+        self.repository.put(H(0), b"foo")
         self.repository.commit(compact=False)
         # append only: does not compact, only new segments written
         assert segments_in_repository() == 4
@@ -438,12 +432,12 @@ class RepositoryAppendOnlyTestCase(RepositoryTestCaseBase):
 class RepositoryFreeSpaceTestCase(RepositoryTestCaseBase):
     def test_additional_free_space(self):
         self.add_keys()
-        self.repository.config.set('repository', 'additional_free_space', '1000T')
-        self.repository.save_key(b'shortcut to save_config')
+        self.repository.config.set("repository", "additional_free_space", "1000T")
+        self.repository.save_key(b"shortcut to save_config")
         self.reopen()
 
         with self.repository:
-            self.repository.put(H(0), b'foobar')
+            self.repository.put(H(0), b"foobar")
             with pytest.raises(Repository.InsufficientFreeSpaceError):
                 self.repository.commit(compact=False)
         assert os.path.exists(self.repository.path)
@@ -469,7 +463,7 @@ class QuotaTestCase(RepositoryTestCaseBase):
         self.reopen()
         with self.repository:
             # Open new transaction; hints and thus quota data is not loaded unless needed.
-            self.repository.put(H(3), b'')
+            self.repository.put(H(3), b"")
             self.repository.delete(H(3))
             assert self.repository.storage_quota_use == 1234 + 5678 + 3 * (41 + 8)  # we have not compacted yet
             self.repository.commit(compact=True)
@@ -478,11 +472,11 @@ class QuotaTestCase(RepositoryTestCaseBase):
     def test_exceed_quota(self):
         assert self.repository.storage_quota_use == 0
         self.repository.storage_quota = 80
-        self.repository.put(H(1), b'')
+        self.repository.put(H(1), b"")
         assert self.repository.storage_quota_use == 41 + 8
         self.repository.commit(compact=False)
         with pytest.raises(Repository.StorageQuotaExceeded):
-            self.repository.put(H(2), b'')
+            self.repository.put(H(2), b"")
         assert self.repository.storage_quota_use == (41 + 8) * 2
         with pytest.raises(Repository.StorageQuotaExceeded):
             self.repository.commit(compact=False)
@@ -491,8 +485,10 @@ class QuotaTestCase(RepositoryTestCaseBase):
         with self.repository:
             self.repository.storage_quota = 150
             # Open new transaction; hints and thus quota data is not loaded unless needed.
-            self.repository.put(H(1), b'')
-            assert self.repository.storage_quota_use == (41 + 8) * 2  # we have 2 puts for H(1) here and not yet compacted.
+            self.repository.put(H(1), b"")
+            assert (
+                self.repository.storage_quota_use == (41 + 8) * 2
+            )  # we have 2 puts for H(1) here and not yet compacted.
             self.repository.commit(compact=True)
             assert self.repository.storage_quota_use == 41 + 8  # now we have compacted.
 
@@ -542,54 +538,54 @@ class NonceReservation(RepositoryTestCaseBase):
 class RepositoryAuxiliaryCorruptionTestCase(RepositoryTestCaseBase):
     def setUp(self):
         super().setUp()
-        self.repository.put(H(0), b'foo')
+        self.repository.put(H(0), b"foo")
         self.repository.commit(compact=False)
         self.repository.close()
 
     def do_commit(self):
         with self.repository:
-            self.repository.put(H(0), b'fox')
+            self.repository.put(H(0), b"fox")
             self.repository.commit(compact=False)
 
     def test_corrupted_hints(self):
-        with open(os.path.join(self.repository.path, 'hints.1'), 'ab') as fd:
-            fd.write(b'123456789')
+        with open(os.path.join(self.repository.path, "hints.1"), "ab") as fd:
+            fd.write(b"123456789")
         self.do_commit()
 
     def test_deleted_hints(self):
-        os.unlink(os.path.join(self.repository.path, 'hints.1'))
+        os.unlink(os.path.join(self.repository.path, "hints.1"))
         self.do_commit()
 
     def test_deleted_index(self):
-        os.unlink(os.path.join(self.repository.path, 'index.1'))
+        os.unlink(os.path.join(self.repository.path, "index.1"))
         self.do_commit()
 
     def test_unreadable_hints(self):
-        hints = os.path.join(self.repository.path, 'hints.1')
+        hints = os.path.join(self.repository.path, "hints.1")
         os.unlink(hints)
         os.mkdir(hints)
         with self.assert_raises(OSError):
             self.do_commit()
 
     def test_index(self):
-        with open(os.path.join(self.repository.path, 'index.1'), 'wb') as fd:
-            fd.write(b'123456789')
+        with open(os.path.join(self.repository.path, "index.1"), "wb") as fd:
+            fd.write(b"123456789")
         self.do_commit()
 
     def test_index_outside_transaction(self):
-        with open(os.path.join(self.repository.path, 'index.1'), 'wb') as fd:
-            fd.write(b'123456789')
+        with open(os.path.join(self.repository.path, "index.1"), "wb") as fd:
+            fd.write(b"123456789")
         with self.repository:
             assert len(self.repository) == 1
 
     def _corrupt_index(self):
         # HashIndex is able to detect incorrect headers and file lengths,
         # but on its own it can't tell if the data is correct.
-        index_path = os.path.join(self.repository.path, 'index.1')
-        with open(index_path, 'r+b') as fd:
+        index_path = os.path.join(self.repository.path, "index.1")
+        with open(index_path, "r+b") as fd:
             index_data = fd.read()
             # Flip one bit in a key stored in the index
-            corrupted_key = (int.from_bytes(H(0), 'little') ^ 1).to_bytes(32, 'little')
+            corrupted_key = (int.from_bytes(H(0), "little") ^ 1).to_bytes(32, "little")
             corrupted_index_data = index_data.replace(H(0), corrupted_key)
             assert corrupted_index_data != index_data
             assert len(corrupted_index_data) == len(index_data)
@@ -604,11 +600,11 @@ class RepositoryAuxiliaryCorruptionTestCase(RepositoryTestCaseBase):
             # Data corruption is detected due to mismatching checksums
             # and fixed by rebuilding the index.
             assert len(self.repository) == 1
-            assert self.repository.get(H(0)) == b'foo'
+            assert self.repository.get(H(0)) == b"foo"
 
     def test_index_corrupted_without_integrity(self):
         self._corrupt_index()
-        integrity_path = os.path.join(self.repository.path, 'integrity.1')
+        integrity_path = os.path.join(self.repository.path, "integrity.1")
         os.unlink(integrity_path)
         with self.repository:
             # Since the corrupted key is not noticed, the repository still thinks
@@ -619,7 +615,7 @@ class RepositoryAuxiliaryCorruptionTestCase(RepositoryTestCaseBase):
                 self.repository.get(H(0))
 
     def test_unreadable_index(self):
-        index = os.path.join(self.repository.path, 'index.1')
+        index = os.path.join(self.repository.path, "index.1")
         os.unlink(index)
         os.mkdir(index)
         with self.assert_raises(OSError):
@@ -627,36 +623,39 @@ class RepositoryAuxiliaryCorruptionTestCase(RepositoryTestCaseBase):
 
     def test_unknown_integrity_version(self):
         # For now an unknown integrity data version is ignored and not an error.
-        integrity_path = os.path.join(self.repository.path, 'integrity.1')
-        with open(integrity_path, 'r+b') as fd:
-            msgpack.pack({
-                # Borg only understands version 2
-                b'version': 4.7,
-            }, fd)
+        integrity_path = os.path.join(self.repository.path, "integrity.1")
+        with open(integrity_path, "r+b") as fd:
+            msgpack.pack(
+                {
+                    # Borg only understands version 2
+                    b"version": 4.7
+                },
+                fd,
+            )
             fd.truncate()
         with self.repository:
             # No issues accessing the repository
             assert len(self.repository) == 1
-            assert self.repository.get(H(0)) == b'foo'
+            assert self.repository.get(H(0)) == b"foo"
 
     def _subtly_corrupted_hints_setup(self):
         with self.repository:
             self.repository.append_only = True
             assert len(self.repository) == 1
-            assert self.repository.get(H(0)) == b'foo'
-            self.repository.put(H(1), b'bar')
-            self.repository.put(H(2), b'baz')
+            assert self.repository.get(H(0)) == b"foo"
+            self.repository.put(H(1), b"bar")
+            self.repository.put(H(2), b"baz")
             self.repository.commit(compact=False)
-            self.repository.put(H(2), b'bazz')
+            self.repository.put(H(2), b"bazz")
             self.repository.commit(compact=False)
 
-        hints_path = os.path.join(self.repository.path, 'hints.5')
-        with open(hints_path, 'r+b') as fd:
+        hints_path = os.path.join(self.repository.path, "hints.5")
+        with open(hints_path, "r+b") as fd:
             hints = msgpack.unpack(fd)
             fd.seek(0)
             # Corrupt segment refcount
-            assert hints['segments'][2] == 1
-            hints['segments'][2] = 0
+            assert hints["segments"][2] == 1
+            hints["segments"][2] = 0
             msgpack.pack(hints, fd)
             fd.truncate()
 
@@ -664,37 +663,40 @@ class RepositoryAuxiliaryCorruptionTestCase(RepositoryTestCaseBase):
         self._subtly_corrupted_hints_setup()
         with self.repository:
             self.repository.append_only = False
-            self.repository.put(H(3), b'1234')
+            self.repository.put(H(3), b"1234")
             # Do a compaction run. Succeeds, since the failed checksum prompted a rebuild of the index+hints.
             self.repository.commit(compact=True)
 
             assert len(self.repository) == 4
-            assert self.repository.get(H(0)) == b'foo'
-            assert self.repository.get(H(1)) == b'bar'
-            assert self.repository.get(H(2)) == b'bazz'
+            assert self.repository.get(H(0)) == b"foo"
+            assert self.repository.get(H(1)) == b"bar"
+            assert self.repository.get(H(2)) == b"bazz"
 
     def test_subtly_corrupted_hints_without_integrity(self):
         self._subtly_corrupted_hints_setup()
-        integrity_path = os.path.join(self.repository.path, 'integrity.5')
+        integrity_path = os.path.join(self.repository.path, "integrity.5")
         os.unlink(integrity_path)
         with self.repository:
             self.repository.append_only = False
-            self.repository.put(H(3), b'1234')
+            self.repository.put(H(3), b"1234")
             # Do a compaction run. Fails, since the corrupted refcount was not detected and leads to an assertion failure.
             with pytest.raises(AssertionError) as exc_info:
                 self.repository.commit(compact=True)
-            assert 'Corrupted segment reference count' in str(exc_info.value)
+            assert "Corrupted segment reference count" in str(exc_info.value)
 
 
 class RepositoryCheckTestCase(RepositoryTestCaseBase):
-
     def list_indices(self):
-        return [name for name in os.listdir(os.path.join(self.tmppath, 'repository')) if name.startswith('index.')]
+        return [name for name in os.listdir(os.path.join(self.tmppath, "repository")) if name.startswith("index.")]
 
     def check(self, repair=False, status=True):
         self.assert_equal(self.repository.check(repair=repair), status)
         # Make sure no tmp files are left behind
-        self.assert_equal([name for name in os.listdir(os.path.join(self.tmppath, 'repository')) if 'tmp' in name], [], 'Found tmp files')
+        self.assert_equal(
+            [name for name in os.listdir(os.path.join(self.tmppath, "repository")) if "tmp" in name],
+            [],
+            "Found tmp files",
+        )
 
     def get_objects(self, *ids):
         for id_ in ids:
@@ -703,31 +705,35 @@ class RepositoryCheckTestCase(RepositoryTestCaseBase):
     def add_objects(self, segments):
         for ids in segments:
             for id_ in ids:
-                self.repository.put(H(id_), b'data')
+                self.repository.put(H(id_), b"data")
             self.repository.commit(compact=False)
 
     def get_head(self):
-        return sorted(int(n) for n in os.listdir(os.path.join(self.tmppath, 'repository', 'data', '0')) if n.isdigit())[-1]
+        return sorted(int(n) for n in os.listdir(os.path.join(self.tmppath, "repository", "data", "0")) if n.isdigit())[
+            -1
+        ]
 
     def open_index(self):
-        return NSIndex.read(os.path.join(self.tmppath, 'repository', f'index.{self.get_head()}'))
+        return NSIndex.read(os.path.join(self.tmppath, "repository", f"index.{self.get_head()}"))
 
     def corrupt_object(self, id_):
         idx = self.open_index()
         segment, offset, _ = idx[H(id_)]
-        with open(os.path.join(self.tmppath, 'repository', 'data', '0', str(segment)), 'r+b') as fd:
+        with open(os.path.join(self.tmppath, "repository", "data", "0", str(segment)), "r+b") as fd:
             fd.seek(offset)
-            fd.write(b'BOOM')
+            fd.write(b"BOOM")
 
     def delete_segment(self, segment):
-        os.unlink(os.path.join(self.tmppath, 'repository', 'data', '0', str(segment)))
+        os.unlink(os.path.join(self.tmppath, "repository", "data", "0", str(segment)))
 
     def delete_index(self):
-        os.unlink(os.path.join(self.tmppath, 'repository', f'index.{self.get_head()}'))
+        os.unlink(os.path.join(self.tmppath, "repository", f"index.{self.get_head()}"))
 
     def rename_index(self, new_name):
-        os.rename(os.path.join(self.tmppath, 'repository', f'index.{self.get_head()}'),
-                  os.path.join(self.tmppath, 'repository', new_name))
+        os.rename(
+            os.path.join(self.tmppath, "repository", f"index.{self.get_head()}"),
+            os.path.join(self.tmppath, "repository", new_name),
+        )
 
     def list_objects(self):
         return {int(key) for key in self.repository.list()}
@@ -765,9 +771,9 @@ class RepositoryCheckTestCase(RepositoryTestCaseBase):
 
     def test_repair_corrupted_commit_segment(self):
         self.add_objects([[1, 2, 3], [4, 5, 6]])
-        with open(os.path.join(self.tmppath, 'repository', 'data', '0', '3'), 'r+b') as fd:
+        with open(os.path.join(self.tmppath, "repository", "data", "0", "3"), "r+b") as fd:
             fd.seek(-1, os.SEEK_END)
-            fd.write(b'X')
+            fd.write(b"X")
         self.assert_raises(Repository.ObjectNotFound, lambda: self.get_objects(4))
         self.check(status=True)
         self.get_objects(3)
@@ -775,15 +781,15 @@ class RepositoryCheckTestCase(RepositoryTestCaseBase):
 
     def test_repair_no_commits(self):
         self.add_objects([[1, 2, 3]])
-        with open(os.path.join(self.tmppath, 'repository', 'data', '0', '1'), 'r+b') as fd:
+        with open(os.path.join(self.tmppath, "repository", "data", "0", "1"), "r+b") as fd:
             fd.seek(-1, os.SEEK_END)
-            fd.write(b'X')
+            fd.write(b"X")
         self.assert_raises(Repository.CheckNeeded, lambda: self.get_objects(4))
         self.check(status=False)
         self.check(status=False)
-        self.assert_equal(self.list_indices(), ['index.1'])
+        self.assert_equal(self.list_indices(), ["index.1"])
         self.check(repair=True, status=True)
-        self.assert_equal(self.list_indices(), ['index.2'])
+        self.assert_equal(self.list_indices(), ["index.2"])
         self.check(status=True)
         self.get_objects(3)
         self.assert_equal({1, 2, 3}, self.list_objects())
@@ -797,30 +803,29 @@ class RepositoryCheckTestCase(RepositoryTestCaseBase):
 
     def test_repair_index_too_new(self):
         self.add_objects([[1, 2, 3], [4, 5, 6]])
-        self.assert_equal(self.list_indices(), ['index.3'])
-        self.rename_index('index.100')
+        self.assert_equal(self.list_indices(), ["index.3"])
+        self.rename_index("index.100")
         self.check(status=True)
-        self.assert_equal(self.list_indices(), ['index.3'])
+        self.assert_equal(self.list_indices(), ["index.3"])
         self.get_objects(4)
         self.assert_equal({1, 2, 3, 4, 5, 6}, self.list_objects())
 
     def test_crash_before_compact(self):
-        self.repository.put(H(0), b'data')
-        self.repository.put(H(0), b'data2')
+        self.repository.put(H(0), b"data")
+        self.repository.put(H(0), b"data2")
         # Simulate a crash before compact
-        with patch.object(Repository, 'compact_segments') as compact:
+        with patch.object(Repository, "compact_segments") as compact:
             self.repository.commit(compact=True)
             compact.assert_called_once_with(0.1)
         self.reopen()
         with self.repository:
             self.check(repair=True)
-            self.assert_equal(self.repository.get(H(0)), b'data2')
+            self.assert_equal(self.repository.get(H(0)), b"data2")
 
 
 class RepositoryHintsTestCase(RepositoryTestCaseBase):
-
     def test_hints_persistence(self):
-        self.repository.put(H(0), b'data')
+        self.repository.put(H(0), b"data")
         self.repository.delete(H(0))
         self.repository.commit(compact=False)
         shadow_index_expected = self.repository.shadow_index
@@ -831,7 +836,7 @@ class RepositoryHintsTestCase(RepositoryTestCaseBase):
         self.reopen()
         with self.repository:
             # see also do_compact()
-            self.repository.put(H(42), b'foobar')  # this will call prepare_txn() and load the hints data
+            self.repository.put(H(42), b"foobar")  # this will call prepare_txn() and load the hints data
             # check if hints persistence worked:
             self.assert_equal(shadow_index_expected, self.repository.shadow_index)
             self.assert_equal(compact_expected, self.repository.compact)
@@ -839,7 +844,7 @@ class RepositoryHintsTestCase(RepositoryTestCaseBase):
             self.assert_equal(segments_expected, self.repository.segments)
 
     def test_hints_behaviour(self):
-        self.repository.put(H(0), b'data')
+        self.repository.put(H(0), b"data")
         self.assert_equal(self.repository.shadow_index, {})
         assert len(self.repository.compact) == 0
         self.repository.delete(H(0))
@@ -848,7 +853,7 @@ class RepositoryHintsTestCase(RepositoryTestCaseBase):
         self.assert_in(H(0), self.repository.shadow_index)
         self.assert_equal(len(self.repository.shadow_index[H(0)]), 1)
         self.assert_in(0, self.repository.compact)  # segment 0 can be compacted
-        self.repository.put(H(42), b'foobar')  # see also do_compact()
+        self.repository.put(H(42), b"foobar")  # see also do_compact()
         self.repository.commit(compact=True, threshold=0.0)  # compact completely!
         # nothing to compact any more! no info left about stuff that does not exist any more:
         self.assert_not_in(H(0), self.repository.shadow_index)
@@ -861,12 +866,13 @@ class RemoteRepositoryTestCase(RepositoryTestCase):
     repository = None  # type: RemoteRepository
 
     def open(self, create=False):
-        return RemoteRepository(Location('ssh://__testsuite__' + os.path.join(self.tmppath, 'repository')),
-                                exclusive=True, create=create)
+        return RemoteRepository(
+            Location("ssh://__testsuite__" + os.path.join(self.tmppath, "repository")), exclusive=True, create=create
+        )
 
     def _get_mock_args(self):
         class MockArgs:
-            remote_path = 'borg'
+            remote_path = "borg"
             umask = 0o077
             debug_topics = []
             rsh = None
@@ -878,111 +884,122 @@ class RemoteRepositoryTestCase(RepositoryTestCase):
         return MockArgs()
 
     def test_invalid_rpc(self):
-        self.assert_raises(InvalidRPCMethod, lambda: self.repository.call('__init__', {}))
+        self.assert_raises(InvalidRPCMethod, lambda: self.repository.call("__init__", {}))
 
     def test_rpc_exception_transport(self):
-        s1 = 'test string'
+        s1 = "test string"
 
         try:
-            self.repository.call('inject_exception', {'kind': 'DoesNotExist'})
+            self.repository.call("inject_exception", {"kind": "DoesNotExist"})
         except Repository.DoesNotExist as e:
             assert len(e.args) == 1
             assert e.args[0] == self.repository.location.processed
 
         try:
-            self.repository.call('inject_exception', {'kind': 'AlreadyExists'})
+            self.repository.call("inject_exception", {"kind": "AlreadyExists"})
         except Repository.AlreadyExists as e:
             assert len(e.args) == 1
             assert e.args[0] == self.repository.location.processed
 
         try:
-            self.repository.call('inject_exception', {'kind': 'CheckNeeded'})
+            self.repository.call("inject_exception", {"kind": "CheckNeeded"})
         except Repository.CheckNeeded as e:
             assert len(e.args) == 1
             assert e.args[0] == self.repository.location.processed
 
         try:
-            self.repository.call('inject_exception', {'kind': 'IntegrityError'})
+            self.repository.call("inject_exception", {"kind": "IntegrityError"})
         except IntegrityError as e:
             assert len(e.args) == 1
             assert e.args[0] == s1
 
         try:
-            self.repository.call('inject_exception', {'kind': 'PathNotAllowed'})
+            self.repository.call("inject_exception", {"kind": "PathNotAllowed"})
         except PathNotAllowed as e:
             assert len(e.args) == 1
-            assert e.args[0] == 'foo'
+            assert e.args[0] == "foo"
 
         try:
-            self.repository.call('inject_exception', {'kind': 'ObjectNotFound'})
+            self.repository.call("inject_exception", {"kind": "ObjectNotFound"})
         except Repository.ObjectNotFound as e:
             assert len(e.args) == 2
             assert e.args[0] == s1
             assert e.args[1] == self.repository.location.processed
 
         try:
-            self.repository.call('inject_exception', {'kind': 'InvalidRPCMethod'})
+            self.repository.call("inject_exception", {"kind": "InvalidRPCMethod"})
         except InvalidRPCMethod as e:
             assert len(e.args) == 1
             assert e.args[0] == s1
 
         try:
-            self.repository.call('inject_exception', {'kind': 'divide'})
+            self.repository.call("inject_exception", {"kind": "divide"})
         except RemoteRepository.RPCError as e:
             assert e.unpacked
-            assert e.get_message() == 'ZeroDivisionError: integer division or modulo by zero\n'
-            assert e.exception_class == 'ZeroDivisionError'
+            assert e.get_message() == "ZeroDivisionError: integer division or modulo by zero\n"
+            assert e.exception_class == "ZeroDivisionError"
             assert len(e.exception_full) > 0
 
     def test_ssh_cmd(self):
         args = self._get_mock_args()
         self.repository._args = args
-        assert self.repository.ssh_cmd(Location('ssh://example.com/foo')) == ['ssh', 'example.com']
-        assert self.repository.ssh_cmd(Location('ssh://user@example.com/foo')) == ['ssh', 'user@example.com']
-        assert self.repository.ssh_cmd(Location('ssh://user@example.com:1234/foo')) == ['ssh', '-p', '1234', 'user@example.com']
-        os.environ['BORG_RSH'] = 'ssh --foo'
-        assert self.repository.ssh_cmd(Location('ssh://example.com/foo')) == ['ssh', '--foo', 'example.com']
+        assert self.repository.ssh_cmd(Location("ssh://example.com/foo")) == ["ssh", "example.com"]
+        assert self.repository.ssh_cmd(Location("ssh://user@example.com/foo")) == ["ssh", "user@example.com"]
+        assert self.repository.ssh_cmd(Location("ssh://user@example.com:1234/foo")) == [
+            "ssh",
+            "-p",
+            "1234",
+            "user@example.com",
+        ]
+        os.environ["BORG_RSH"] = "ssh --foo"
+        assert self.repository.ssh_cmd(Location("ssh://example.com/foo")) == ["ssh", "--foo", "example.com"]
 
     def test_borg_cmd(self):
-        assert self.repository.borg_cmd(None, testing=True) == [sys.executable, '-m', 'borg.archiver', 'serve']
+        assert self.repository.borg_cmd(None, testing=True) == [sys.executable, "-m", "borg.archiver", "serve"]
         args = self._get_mock_args()
         # XXX without next line we get spurious test fails when using pytest-xdist, root cause unknown:
         logging.getLogger().setLevel(logging.INFO)
         # note: test logger is on info log level, so --info gets added automagically
-        assert self.repository.borg_cmd(args, testing=False) == ['borg', 'serve', '--info']
-        args.remote_path = 'borg-0.28.2'
-        assert self.repository.borg_cmd(args, testing=False) == ['borg-0.28.2', 'serve', '--info']
-        args.debug_topics = ['something_client_side', 'repository_compaction']
-        assert self.repository.borg_cmd(args, testing=False) == ['borg-0.28.2', 'serve', '--info',
-                                                                 '--debug-topic=borg.debug.repository_compaction']
+        assert self.repository.borg_cmd(args, testing=False) == ["borg", "serve", "--info"]
+        args.remote_path = "borg-0.28.2"
+        assert self.repository.borg_cmd(args, testing=False) == ["borg-0.28.2", "serve", "--info"]
+        args.debug_topics = ["something_client_side", "repository_compaction"]
+        assert self.repository.borg_cmd(args, testing=False) == [
+            "borg-0.28.2",
+            "serve",
+            "--info",
+            "--debug-topic=borg.debug.repository_compaction",
+        ]
         args = self._get_mock_args()
         args.storage_quota = 0
-        assert self.repository.borg_cmd(args, testing=False) == ['borg', 'serve', '--info']
+        assert self.repository.borg_cmd(args, testing=False) == ["borg", "serve", "--info"]
         args.storage_quota = 314159265
-        assert self.repository.borg_cmd(args, testing=False) == ['borg', 'serve', '--info',
-                                                                 '--storage-quota=314159265']
-        args.rsh = 'ssh -i foo'
+        assert self.repository.borg_cmd(args, testing=False) == ["borg", "serve", "--info", "--storage-quota=314159265"]
+        args.rsh = "ssh -i foo"
         self.repository._args = args
-        assert self.repository.ssh_cmd(Location('ssh://example.com/foo')) == ['ssh', '-i', 'foo', 'example.com']
+        assert self.repository.ssh_cmd(Location("ssh://example.com/foo")) == ["ssh", "-i", "foo", "example.com"]
 
 
 class RemoteLegacyFree(RepositoryTestCaseBase):
     # Keep testing this so we can someday safely remove the legacy tuple format.
 
     def open(self, create=False):
-        with patch.object(RemoteRepository, 'dictFormat', True):
-            return RemoteRepository(Location('ssh://__testsuite__' + os.path.join(self.tmppath, 'repository')),
-                                    exclusive=True, create=create)
+        with patch.object(RemoteRepository, "dictFormat", True):
+            return RemoteRepository(
+                Location("ssh://__testsuite__" + os.path.join(self.tmppath, "repository")),
+                exclusive=True,
+                create=create,
+            )
 
     def test_legacy_free(self):
         # put
-        self.repository.put(H(0), b'foo')
+        self.repository.put(H(0), b"foo")
         self.repository.commit(compact=False)
         self.repository.close()
         # replace
         self.repository = self.open()
         with self.repository:
-            self.repository.put(H(0), b'bar')
+            self.repository.put(H(0), b"bar")
             self.repository.commit(compact=False)
         # delete
         self.repository = self.open()
@@ -992,10 +1009,10 @@ class RemoteLegacyFree(RepositoryTestCaseBase):
 
 
 class RemoteRepositoryCheckTestCase(RepositoryCheckTestCase):
-
     def open(self, create=False):
-        return RemoteRepository(Location('ssh://__testsuite__' + os.path.join(self.tmppath, 'repository')),
-                                exclusive=True, create=create)
+        return RemoteRepository(
+            Location("ssh://__testsuite__" + os.path.join(self.tmppath, "repository")), exclusive=True, create=create
+        )
 
     def test_crash_before_compact(self):
         # skip this test, we can't mock-patch a Repository class in another process!
@@ -1007,8 +1024,8 @@ class RemoteLoggerTestCase(BaseTestCase):
         self.stream = io.StringIO()
         self.handler = logging.StreamHandler(self.stream)
         logging.getLogger().handlers[:] = [self.handler]
-        logging.getLogger('borg.repository').handlers[:] = []
-        logging.getLogger('borg.repository.foo').handlers[:] = []
+        logging.getLogger("borg.repository").handlers[:] = []
+        logging.getLogger("borg.repository.foo").handlers[:] = []
         # capture stderr
         sys.stderr.flush()
         self.old_stderr = sys.stderr
@@ -1019,31 +1036,31 @@ class RemoteLoggerTestCase(BaseTestCase):
 
     def test_stderr_messages(self):
         handle_remote_line("unstructured stderr message\n")
-        self.assert_equal(self.stream.getvalue(), '')
+        self.assert_equal(self.stream.getvalue(), "")
         # stderr messages don't get an implicit newline
-        self.assert_equal(self.stderr.getvalue(), 'Remote: unstructured stderr message\n')
+        self.assert_equal(self.stderr.getvalue(), "Remote: unstructured stderr message\n")
 
     def test_stderr_progress_messages(self):
         handle_remote_line("unstructured stderr progress message\r")
-        self.assert_equal(self.stream.getvalue(), '')
+        self.assert_equal(self.stream.getvalue(), "")
         # stderr messages don't get an implicit newline
-        self.assert_equal(self.stderr.getvalue(), 'Remote: unstructured stderr progress message\r')
+        self.assert_equal(self.stderr.getvalue(), "Remote: unstructured stderr progress message\r")
 
     def test_pre11_format_messages(self):
         self.handler.setLevel(logging.DEBUG)
         logging.getLogger().setLevel(logging.DEBUG)
 
         handle_remote_line("$LOG INFO Remote: borg < 1.1 format message\n")
-        self.assert_equal(self.stream.getvalue(), 'Remote: borg < 1.1 format message\n')
-        self.assert_equal(self.stderr.getvalue(), '')
+        self.assert_equal(self.stream.getvalue(), "Remote: borg < 1.1 format message\n")
+        self.assert_equal(self.stderr.getvalue(), "")
 
     def test_post11_format_messages(self):
         self.handler.setLevel(logging.DEBUG)
         logging.getLogger().setLevel(logging.DEBUG)
 
         handle_remote_line("$LOG INFO borg.repository Remote: borg >= 1.1 format message\n")
-        self.assert_equal(self.stream.getvalue(), 'Remote: borg >= 1.1 format message\n')
-        self.assert_equal(self.stderr.getvalue(), '')
+        self.assert_equal(self.stream.getvalue(), "Remote: borg >= 1.1 format message\n")
+        self.assert_equal(self.stderr.getvalue(), "")
 
     def test_remote_messages_screened(self):
         # default borg config for root logger
@@ -1051,12 +1068,12 @@ class RemoteLoggerTestCase(BaseTestCase):
         logging.getLogger().setLevel(logging.WARNING)
 
         handle_remote_line("$LOG INFO borg.repository Remote: new format info message\n")
-        self.assert_equal(self.stream.getvalue(), '')
-        self.assert_equal(self.stderr.getvalue(), '')
+        self.assert_equal(self.stream.getvalue(), "")
+        self.assert_equal(self.stderr.getvalue(), "")
 
     def test_info_to_correct_local_child(self):
-        logging.getLogger('borg.repository').setLevel(logging.INFO)
-        logging.getLogger('borg.repository.foo').setLevel(logging.INFO)
+        logging.getLogger("borg.repository").setLevel(logging.INFO)
+        logging.getLogger("borg.repository.foo").setLevel(logging.INFO)
         # default borg config for root logger
         self.handler.setLevel(logging.WARNING)
         logging.getLogger().setLevel(logging.WARNING)
@@ -1064,14 +1081,14 @@ class RemoteLoggerTestCase(BaseTestCase):
         child_stream = io.StringIO()
         child_handler = logging.StreamHandler(child_stream)
         child_handler.setLevel(logging.INFO)
-        logging.getLogger('borg.repository').handlers[:] = [child_handler]
+        logging.getLogger("borg.repository").handlers[:] = [child_handler]
         foo_stream = io.StringIO()
         foo_handler = logging.StreamHandler(foo_stream)
         foo_handler.setLevel(logging.INFO)
-        logging.getLogger('borg.repository.foo').handlers[:] = [foo_handler]
+        logging.getLogger("borg.repository.foo").handlers[:] = [foo_handler]
 
         handle_remote_line("$LOG INFO borg.repository Remote: new format child message\n")
-        self.assert_equal(foo_stream.getvalue(), '')
-        self.assert_equal(child_stream.getvalue(), 'Remote: new format child message\n')
-        self.assert_equal(self.stream.getvalue(), '')
-        self.assert_equal(self.stderr.getvalue(), '')
+        self.assert_equal(foo_stream.getvalue(), "")
+        self.assert_equal(child_stream.getvalue(), "Remote: new format child message\n")
+        self.assert_equal(self.stream.getvalue(), "")
+        self.assert_equal(self.stderr.getvalue(), "")
diff --git a/src/borg/testsuite/shellpattern.py b/src/borg/testsuite/shellpattern.py
index 5ca5af400..d0428ccda 100644
--- a/src/borg/testsuite/shellpattern.py
+++ b/src/borg/testsuite/shellpattern.py
@@ -11,103 +11,96 @@ def check(path, pattern):
     return bool(compiled.match(path))
 
 
-@pytest.mark.parametrize("path, patterns", [
-    # Literal string
-    ("foo/bar", ["foo/bar"]),
-    ("foo\\bar", ["foo\\bar"]),
-
-    # Non-ASCII
-    ("foo/c/\u0152/e/bar", ["foo/*/\u0152/*/bar", "*/*/\u0152/*/*", "**/\u0152/*/*"]),
-    ("\u00e4\u00f6\u00dc", ["???", "*", "\u00e4\u00f6\u00dc", "[\u00e4][\u00f6][\u00dc]"]),
-
-    # Question mark
-    ("foo", ["fo?"]),
-    ("foo", ["f?o"]),
-    ("foo", ["f??"]),
-    ("foo", ["?oo"]),
-    ("foo", ["?o?"]),
-    ("foo", ["??o"]),
-    ("foo", ["???"]),
-
-    # Single asterisk
-    ("", ["*"]),
-    ("foo", ["*", "**", "***"]),
-    ("foo", ["foo*"]),
-    ("foobar", ["foo*"]),
-    ("foobar", ["foo*bar"]),
-    ("foobarbaz", ["foo*baz"]),
-    ("bar", ["*bar"]),
-    ("foobar", ["*bar"]),
-    ("foo/bar", ["foo/*bar"]),
-    ("foo/bar", ["foo/*ar"]),
-    ("foo/bar", ["foo/*r"]),
-    ("foo/bar", ["foo/*"]),
-    ("foo/bar", ["foo*/bar"]),
-    ("foo/bar", ["fo*/bar"]),
-    ("foo/bar", ["f*/bar"]),
-    ("foo/bar", ["*/bar"]),
-
-    # Double asterisk (matches 0..n directory layers)
-    ("foo/bar", ["foo/**/bar"]),
-    ("foo/1/bar", ["foo/**/bar"]),
-    ("foo/1/22/333/bar", ["foo/**/bar"]),
-    ("foo/", ["foo/**/"]),
-    ("foo/1/", ["foo/**/"]),
-    ("foo/1/22/333/", ["foo/**/"]),
-    ("bar", ["**/bar"]),
-    ("1/bar", ["**/bar"]),
-    ("1/22/333/bar", ["**/bar"]),
-    ("foo/bar/baz", ["foo/**/*"]),
-
-    # Set
-    ("foo1", ["foo[12]"]),
-    ("foo2", ["foo[12]"]),
-    ("foo2/bar", ["foo[12]/*"]),
-    ("f??f", ["f??f", "f[?][?]f"]),
-    ("foo]", ["foo[]]"]),
-
-    # Inverted set
-    ("foo3", ["foo[!12]"]),
-    ("foo^", ["foo[^!]"]),
-    ("foo!", ["foo[^!]"]),
-    ])
+@pytest.mark.parametrize(
+    "path, patterns",
+    [
+        # Literal string
+        ("foo/bar", ["foo/bar"]),
+        ("foo\\bar", ["foo\\bar"]),
+        # Non-ASCII
+        ("foo/c/\u0152/e/bar", ["foo/*/\u0152/*/bar", "*/*/\u0152/*/*", "**/\u0152/*/*"]),
+        ("\u00e4\u00f6\u00dc", ["???", "*", "\u00e4\u00f6\u00dc", "[\u00e4][\u00f6][\u00dc]"]),
+        # Question mark
+        ("foo", ["fo?"]),
+        ("foo", ["f?o"]),
+        ("foo", ["f??"]),
+        ("foo", ["?oo"]),
+        ("foo", ["?o?"]),
+        ("foo", ["??o"]),
+        ("foo", ["???"]),
+        # Single asterisk
+        ("", ["*"]),
+        ("foo", ["*", "**", "***"]),
+        ("foo", ["foo*"]),
+        ("foobar", ["foo*"]),
+        ("foobar", ["foo*bar"]),
+        ("foobarbaz", ["foo*baz"]),
+        ("bar", ["*bar"]),
+        ("foobar", ["*bar"]),
+        ("foo/bar", ["foo/*bar"]),
+        ("foo/bar", ["foo/*ar"]),
+        ("foo/bar", ["foo/*r"]),
+        ("foo/bar", ["foo/*"]),
+        ("foo/bar", ["foo*/bar"]),
+        ("foo/bar", ["fo*/bar"]),
+        ("foo/bar", ["f*/bar"]),
+        ("foo/bar", ["*/bar"]),
+        # Double asterisk (matches 0..n directory layers)
+        ("foo/bar", ["foo/**/bar"]),
+        ("foo/1/bar", ["foo/**/bar"]),
+        ("foo/1/22/333/bar", ["foo/**/bar"]),
+        ("foo/", ["foo/**/"]),
+        ("foo/1/", ["foo/**/"]),
+        ("foo/1/22/333/", ["foo/**/"]),
+        ("bar", ["**/bar"]),
+        ("1/bar", ["**/bar"]),
+        ("1/22/333/bar", ["**/bar"]),
+        ("foo/bar/baz", ["foo/**/*"]),
+        # Set
+        ("foo1", ["foo[12]"]),
+        ("foo2", ["foo[12]"]),
+        ("foo2/bar", ["foo[12]/*"]),
+        ("f??f", ["f??f", "f[?][?]f"]),
+        ("foo]", ["foo[]]"]),
+        # Inverted set
+        ("foo3", ["foo[!12]"]),
+        ("foo^", ["foo[^!]"]),
+        ("foo!", ["foo[^!]"]),
+    ],
+)
 def test_match(path, patterns):
     for p in patterns:
         assert check(path, p)
 
 
-@pytest.mark.parametrize("path, patterns", [
-    ("", ["?", "[]"]),
-    ("foo", ["foo?"]),
-    ("foo", ["?foo"]),
-    ("foo", ["f?oo"]),
-
-    # do not match path separator
-    ("foo/ar", ["foo?ar"]),
-
-    # do not match/cross over os.path.sep
-    ("foo/bar", ["*"]),
-    ("foo/bar", ["foo*bar"]),
-    ("foo/bar", ["foo*ar"]),
-    ("foo/bar", ["fo*bar"]),
-    ("foo/bar", ["fo*ar"]),
-
-    # Double asterisk
-    ("foobar", ["foo/**/bar"]),
-
-    # Two asterisks without slash do not match directory separator
-    ("foo/bar", ["**"]),
-
-    # Double asterisk not matching filename
-    ("foo/bar", ["**/"]),
-
-    # Set
-    ("foo3", ["foo[12]"]),
-
-    # Inverted set
-    ("foo1", ["foo[!12]"]),
-    ("foo2", ["foo[!12]"]),
-    ])
+@pytest.mark.parametrize(
+    "path, patterns",
+    [
+        ("", ["?", "[]"]),
+        ("foo", ["foo?"]),
+        ("foo", ["?foo"]),
+        ("foo", ["f?oo"]),
+        # do not match path separator
+        ("foo/ar", ["foo?ar"]),
+        # do not match/cross over os.path.sep
+        ("foo/bar", ["*"]),
+        ("foo/bar", ["foo*bar"]),
+        ("foo/bar", ["foo*ar"]),
+        ("foo/bar", ["fo*bar"]),
+        ("foo/bar", ["fo*ar"]),
+        # Double asterisk
+        ("foobar", ["foo/**/bar"]),
+        # Two asterisks without slash do not match directory separator
+        ("foo/bar", ["**"]),
+        # Double asterisk not matching filename
+        ("foo/bar", ["**/"]),
+        # Set
+        ("foo3", ["foo[12]"]),
+        # Inverted set
+        ("foo1", ["foo[!12]"]),
+        ("foo2", ["foo[!12]"]),
+    ],
+)
 def test_mismatch(path, patterns):
     for p in patterns:
         assert not check(path, p)
@@ -115,10 +108,10 @@ def test_mismatch(path, patterns):
 
 def test_match_end():
     regex = shellpattern.translate("*-home")  # default is match_end == string end
-    assert re.match(regex, '2017-07-03-home')
-    assert not re.match(regex, '2017-07-03-home.checkpoint')
+    assert re.match(regex, "2017-07-03-home")
+    assert not re.match(regex, "2017-07-03-home.checkpoint")
 
-    match_end = r'(%s)?\Z' % r'\.checkpoint(\.\d+)?'  # with/without checkpoint ending
+    match_end = r"(%s)?\Z" % r"\.checkpoint(\.\d+)?"  # with/without checkpoint ending
     regex = shellpattern.translate("*-home", match_end=match_end)
-    assert re.match(regex, '2017-07-03-home')
-    assert re.match(regex, '2017-07-03-home.checkpoint')
+    assert re.match(regex, "2017-07-03-home")
+    assert re.match(regex, "2017-07-03-home.checkpoint")
diff --git a/src/borg/testsuite/version.py b/src/borg/testsuite/version.py
index d17dee0e7..d7f32b7c1 100644
--- a/src/borg/testsuite/version.py
+++ b/src/borg/testsuite/version.py
@@ -3,51 +3,57 @@ import pytest
 from ..version import parse_version, format_version
 
 
-@pytest.mark.parametrize("version_str, version_tuple", [
-    # setuptools < 8.0 uses "-"
-    ('1.0.0a1.dev204-g8866961.d20170606', (1, 0, 0, -4, 1)),
-    ('1.0.0a1.dev204-g8866961', (1, 0, 0, -4, 1)),
-    ('1.0.0-d20170606', (1, 0, 0, -1)),
-    # setuptools >= 8.0 uses "+"
-    ('1.0.0a1.dev204+g8866961.d20170606', (1, 0, 0, -4, 1)),
-    ('1.0.0a1.dev204+g8866961', (1, 0, 0, -4, 1)),
-    ('1.0.0+d20170606', (1, 0, 0, -1)),
-    # pre-release versions:
-    ('1.0.0a1', (1, 0, 0, -4, 1)),
-    ('1.0.0a2', (1, 0, 0, -4, 2)),
-    ('1.0.0b3', (1, 0, 0, -3, 3)),
-    ('1.0.0rc4', (1, 0, 0, -2, 4)),
-    # release versions:
-    ('0.0.0', (0, 0, 0, -1)),
-    ('0.0.11', (0, 0, 11, -1)),
-    ('0.11.0', (0, 11, 0, -1)),
-    ('11.0.0', (11, 0, 0, -1)),
-])
+@pytest.mark.parametrize(
+    "version_str, version_tuple",
+    [
+        # setuptools < 8.0 uses "-"
+        ("1.0.0a1.dev204-g8866961.d20170606", (1, 0, 0, -4, 1)),
+        ("1.0.0a1.dev204-g8866961", (1, 0, 0, -4, 1)),
+        ("1.0.0-d20170606", (1, 0, 0, -1)),
+        # setuptools >= 8.0 uses "+"
+        ("1.0.0a1.dev204+g8866961.d20170606", (1, 0, 0, -4, 1)),
+        ("1.0.0a1.dev204+g8866961", (1, 0, 0, -4, 1)),
+        ("1.0.0+d20170606", (1, 0, 0, -1)),
+        # pre-release versions:
+        ("1.0.0a1", (1, 0, 0, -4, 1)),
+        ("1.0.0a2", (1, 0, 0, -4, 2)),
+        ("1.0.0b3", (1, 0, 0, -3, 3)),
+        ("1.0.0rc4", (1, 0, 0, -2, 4)),
+        # release versions:
+        ("0.0.0", (0, 0, 0, -1)),
+        ("0.0.11", (0, 0, 11, -1)),
+        ("0.11.0", (0, 11, 0, -1)),
+        ("11.0.0", (11, 0, 0, -1)),
+    ],
+)
 def test_parse_version(version_str, version_tuple):
     assert parse_version(version_str) == version_tuple
 
 
 def test_parse_version_invalid():
     with pytest.raises(ValueError):
-        assert parse_version('')  # we require x.y.z versions
+        assert parse_version("")  # we require x.y.z versions
     with pytest.raises(ValueError):
-        assert parse_version('1')  # we require x.y.z versions
+        assert parse_version("1")  # we require x.y.z versions
     with pytest.raises(ValueError):
-        assert parse_version('1.2')  # we require x.y.z versions
+        assert parse_version("1.2")  # we require x.y.z versions
     with pytest.raises(ValueError):
-        assert parse_version('crap')
+        assert parse_version("crap")
 
 
-@pytest.mark.parametrize("version_str, version_tuple", [
-    ('1.0.0a1', (1, 0, 0, -4, 1)),
-    ('1.0.0', (1, 0, 0, -1)),
-    ('1.0.0a2', (1, 0, 0, -4, 2)),
-    ('1.0.0b3', (1, 0, 0, -3, 3)),
-    ('1.0.0rc4', (1, 0, 0, -2, 4)),
-    ('0.0.0', (0, 0, 0, -1)),
-    ('0.0.11', (0, 0, 11, -1)),
-    ('0.11.0', (0, 11, 0, -1)),
-    ('11.0.0', (11, 0, 0, -1)),
-])
+@pytest.mark.parametrize(
+    "version_str, version_tuple",
+    [
+        ("1.0.0a1", (1, 0, 0, -4, 1)),
+        ("1.0.0", (1, 0, 0, -1)),
+        ("1.0.0a2", (1, 0, 0, -4, 2)),
+        ("1.0.0b3", (1, 0, 0, -3, 3)),
+        ("1.0.0rc4", (1, 0, 0, -2, 4)),
+        ("0.0.0", (0, 0, 0, -1)),
+        ("0.0.11", (0, 0, 11, -1)),
+        ("0.11.0", (0, 11, 0, -1)),
+        ("11.0.0", (11, 0, 0, -1)),
+    ],
+)
 def test_format_version(version_str, version_tuple):
     assert format_version(version_tuple) == version_str
diff --git a/src/borg/testsuite/xattr.py b/src/borg/testsuite/xattr.py
index 944975bfd..947f287e8 100644
--- a/src/borg/testsuite/xattr.py
+++ b/src/borg/testsuite/xattr.py
@@ -10,12 +10,11 @@ from ..platformflags import is_linux
 from . import BaseTestCase
 
 
-@unittest.skipUnless(is_enabled(), 'xattr not enabled on filesystem')
+@unittest.skipUnless(is_enabled(), "xattr not enabled on filesystem")
 class XattrTestCase(BaseTestCase):
-
     def setUp(self):
         self.tmpfile = tempfile.NamedTemporaryFile()
-        self.symlink = self.tmpfile.name + '.symlink'
+        self.symlink = self.tmpfile.name + ".symlink"
         os.symlink(self.tmpfile.name, self.symlink)
 
     def tearDown(self):
@@ -23,7 +22,7 @@ class XattrTestCase(BaseTestCase):
 
     def assert_equal_se(self, is_x, want_x):
         # check 2 xattr lists for equality, but ignore security.selinux attr
-        is_x = set(is_x) - {b'security.selinux'}
+        is_x = set(is_x) - {b"security.selinux"}
         want_x = set(want_x)
         self.assert_equal(is_x, want_x)
 
@@ -34,32 +33,32 @@ class XattrTestCase(BaseTestCase):
         self.assert_equal_se(listxattr(tmp_fn), [])
         self.assert_equal_se(listxattr(tmp_fd), [])
         self.assert_equal_se(listxattr(tmp_lfn), [])
-        setxattr(tmp_fn, b'user.foo', b'bar')
-        setxattr(tmp_fd, b'user.bar', b'foo')
-        setxattr(tmp_fn, b'user.empty', b'')
+        setxattr(tmp_fn, b"user.foo", b"bar")
+        setxattr(tmp_fd, b"user.bar", b"foo")
+        setxattr(tmp_fn, b"user.empty", b"")
         if not is_linux:
             # linux does not allow setting user.* xattrs on symlinks
-            setxattr(tmp_lfn, b'user.linkxattr', b'baz')
-        self.assert_equal_se(listxattr(tmp_fn), [b'user.foo', b'user.bar', b'user.empty'])
-        self.assert_equal_se(listxattr(tmp_fd), [b'user.foo', b'user.bar', b'user.empty'])
-        self.assert_equal_se(listxattr(tmp_lfn, follow_symlinks=True), [b'user.foo', b'user.bar', b'user.empty'])
+            setxattr(tmp_lfn, b"user.linkxattr", b"baz")
+        self.assert_equal_se(listxattr(tmp_fn), [b"user.foo", b"user.bar", b"user.empty"])
+        self.assert_equal_se(listxattr(tmp_fd), [b"user.foo", b"user.bar", b"user.empty"])
+        self.assert_equal_se(listxattr(tmp_lfn, follow_symlinks=True), [b"user.foo", b"user.bar", b"user.empty"])
         if not is_linux:
-            self.assert_equal_se(listxattr(tmp_lfn), [b'user.linkxattr'])
-        self.assert_equal(getxattr(tmp_fn, b'user.foo'), b'bar')
-        self.assert_equal(getxattr(tmp_fd, b'user.foo'), b'bar')
-        self.assert_equal(getxattr(tmp_lfn, b'user.foo', follow_symlinks=True), b'bar')
+            self.assert_equal_se(listxattr(tmp_lfn), [b"user.linkxattr"])
+        self.assert_equal(getxattr(tmp_fn, b"user.foo"), b"bar")
+        self.assert_equal(getxattr(tmp_fd, b"user.foo"), b"bar")
+        self.assert_equal(getxattr(tmp_lfn, b"user.foo", follow_symlinks=True), b"bar")
         if not is_linux:
-            self.assert_equal(getxattr(tmp_lfn, b'user.linkxattr'), b'baz')
-        self.assert_equal(getxattr(tmp_fn, b'user.empty'), b'')
+            self.assert_equal(getxattr(tmp_lfn, b"user.linkxattr"), b"baz")
+        self.assert_equal(getxattr(tmp_fn, b"user.empty"), b"")
 
     def test_listxattr_buffer_growth(self):
         tmp_fn = os.fsencode(self.tmpfile.name)
         # make it work even with ext4, which imposes rather low limits
         buffer.resize(size=64, init=True)
         # xattr raw key list will be > 64
-        keys = [b'user.attr%d' % i for i in range(20)]
+        keys = [b"user.attr%d" % i for i in range(20)]
         for key in keys:
-            setxattr(tmp_fn, key, b'x')
+            setxattr(tmp_fn, key, b"x")
         got_keys = listxattr(tmp_fn)
         self.assert_equal_se(got_keys, keys)
         assert len(buffer) > 64
@@ -68,18 +67,15 @@ class XattrTestCase(BaseTestCase):
         tmp_fn = os.fsencode(self.tmpfile.name)
         # make it work even with ext4, which imposes rather low limits
         buffer.resize(size=64, init=True)
-        value = b'x' * 126
-        setxattr(tmp_fn, b'user.big', value)
-        got_value = getxattr(tmp_fn, b'user.big')
+        value = b"x" * 126
+        setxattr(tmp_fn, b"user.big", value)
+        got_value = getxattr(tmp_fn, b"user.big")
         self.assert_equal(value, got_value)
         self.assert_equal(len(buffer), 128)
 
 
-@pytest.mark.parametrize('lstring, splitted', (
-    (b'', []),
-    (b'\x00', [b'']),
-    (b'\x01a', [b'a']),
-    (b'\x01a\x02cd', [b'a', b'cd']),
-))
+@pytest.mark.parametrize(
+    "lstring, splitted", ((b"", []), (b"\x00", [b""]), (b"\x01a", [b"a"]), (b"\x01a\x02cd", [b"a", b"cd"]))
+)
 def test_split_lstring(lstring, splitted):
     assert split_lstring(lstring) == splitted
diff --git a/src/borg/upgrade.py b/src/borg/upgrade.py
index 1dfef64ec..329fa7983 100644
--- a/src/borg/upgrade.py
+++ b/src/borg/upgrade.py
@@ -25,8 +25,16 @@ class UpgraderNoOp:
     def upgrade_archive_metadata(self, *, metadata):
         new_metadata = {}
         # keep all metadata except archive version and stats.
-        for attr in ('cmdline', 'hostname', 'username', 'time', 'time_end', 'comment',
-                     'chunker_params', 'recreate_cmdline'):
+        for attr in (
+            "cmdline",
+            "hostname",
+            "username",
+            "time",
+            "time_end",
+            "comment",
+            "chunker_params",
+            "recreate_cmdline",
+        ):
             if hasattr(metadata, attr):
                 new_metadata[attr] = getattr(metadata, attr)
         return new_metadata
@@ -42,24 +50,45 @@ class UpgraderFrom12To20:
 
     def upgrade_item(self, *, item):
         """upgrade item as needed, get rid of legacy crap"""
-        ITEM_KEY_WHITELIST = {'path', 'source', 'rdev', 'chunks', 'chunks_healthy', 'hlid',
-                              'mode', 'user', 'group', 'uid', 'gid', 'mtime', 'atime', 'ctime', 'birthtime', 'size',
-                              'xattrs', 'bsdflags', 'acl_nfs4', 'acl_access', 'acl_default', 'acl_extended',
-                              'part'}
+        ITEM_KEY_WHITELIST = {
+            "path",
+            "source",
+            "rdev",
+            "chunks",
+            "chunks_healthy",
+            "hlid",
+            "mode",
+            "user",
+            "group",
+            "uid",
+            "gid",
+            "mtime",
+            "atime",
+            "ctime",
+            "birthtime",
+            "size",
+            "xattrs",
+            "bsdflags",
+            "acl_nfs4",
+            "acl_access",
+            "acl_default",
+            "acl_extended",
+            "part",
+        }
 
         if self.hlm.borg1_hardlink_master(item):
-            item._dict['hlid'] = hlid = self.hlm.hardlink_id_from_path(item._dict['path'])
-            self.hlm.remember(id=hlid, info=(item._dict.get('chunks'), item._dict.get('chunks_healthy')))
+            item._dict["hlid"] = hlid = self.hlm.hardlink_id_from_path(item._dict["path"])
+            self.hlm.remember(id=hlid, info=(item._dict.get("chunks"), item._dict.get("chunks_healthy")))
         elif self.hlm.borg1_hardlink_slave(item):
-            item._dict['hlid'] = hlid = self.hlm.hardlink_id_from_path(item._dict['source'])
+            item._dict["hlid"] = hlid = self.hlm.hardlink_id_from_path(item._dict["source"])
             chunks, chunks_healthy = self.hlm.retrieve(id=hlid, default=(None, None))
             if chunks is not None:
-                item._dict['chunks'] = chunks
+                item._dict["chunks"] = chunks
                 for chunk_id, _ in chunks:
                     self.cache.chunk_incref(chunk_id, self.archive.stats)
             if chunks_healthy is not None:
-                item._dict['chunks_healthy'] = chunks
-            item._dict.pop('source')  # not used for hardlinks any more, replaced by hlid
+                item._dict["chunks_healthy"] = chunks
+            item._dict.pop("source")  # not used for hardlinks any more, replaced by hlid
         # make sure we only have desired stuff in the new item. specifically, make sure to get rid of:
         # - 'acl' remnants of bug in attic <= 0.13
         # - 'hardlink_master' (superseded by hlid)
@@ -80,17 +109,17 @@ class UpgraderFrom12To20:
             return chunk
 
         ctype = chunk[0:1]
-        level = b'\xFF'  # FF means unknown compression level
+        level = b"\xFF"  # FF means unknown compression level
 
         if ctype == ObfuscateSize.ID:
             # in older borg, we used unusual byte order
-            old_header_fmt = Struct('>I')
+            old_header_fmt = Struct(">I")
             new_header_fmt = ObfuscateSize.header_fmt
             length = ObfuscateSize.header_len
-            size_bytes = chunk[2:2+length]
+            size_bytes = chunk[2 : 2 + length]
             size = old_header_fmt.unpack(size_bytes)
             size_bytes = new_header_fmt.pack(size)
-            compressed = chunk[2+length:]
+            compressed = chunk[2 + length :]
             compressed = upgrade_zlib_and_level(compressed)
             chunk = ctype + level + size_bytes + compressed
         else:
@@ -101,8 +130,16 @@ class UpgraderFrom12To20:
         new_metadata = {}
         # keep all metadata except archive version and stats. also do not keep
         # recreate_source_id, recreate_args, recreate_partial_chunks which were used only in 1.1.0b1 .. b2.
-        for attr in ('cmdline', 'hostname', 'username', 'time', 'time_end', 'comment',
-                     'chunker_params', 'recreate_cmdline'):
+        for attr in (
+            "cmdline",
+            "hostname",
+            "username",
+            "time",
+            "time_end",
+            "comment",
+            "chunker_params",
+            "recreate_cmdline",
+        ):
             if hasattr(metadata, attr):
                 new_metadata[attr] = getattr(metadata, attr)
         return new_metadata
diff --git a/src/borg/version.py b/src/borg/version.py
index a7a997f7b..278054f2e 100644
--- a/src/borg/version.py
+++ b/src/borg/version.py
@@ -21,12 +21,12 @@ def parse_version(version):
     """
     m = re.match(version_re, version, re.VERBOSE)
     if m is None:
-        raise ValueError('Invalid version string %s' % version)
+        raise ValueError("Invalid version string %s" % version)
     gd = m.groupdict()
-    version = [int(gd['major']), int(gd['minor']), int(gd['patch'])]
-    if m.lastgroup == 'prerelease':
-        p_type = {'a': -4, 'b': -3, 'rc': -2}[gd['ptype']]
-        p_num = int(gd['pnum'])
+    version = [int(gd["major"]), int(gd["minor"]), int(gd["patch"])]
+    if m.lastgroup == "prerelease":
+        p_type = {"a": -4, "b": -3, "rc": -2}[gd["ptype"]]
+        p_num = int(gd["pnum"])
         version += [p_type, p_num]
     else:
         version += [-1]
@@ -44,6 +44,6 @@ def format_version(version):
         elif part == -1:
             break
         else:
-            f[-1] = f[-1] + {-2: 'rc', -3: 'b', -4: 'a'}[part] + str(next(it))
+            f[-1] = f[-1] + {-2: "rc", -3: "b", -4: "a"}[part] + str(next(it))
             break
-    return '.'.join(f)
+    return ".".join(f)
diff --git a/src/borg/xattr.py b/src/borg/xattr.py
index 175f6372c..7fd2680cd 100644
--- a/src/borg/xattr.py
+++ b/src/borg/xattr.py
@@ -22,14 +22,14 @@ from .platform import listxattr, getxattr, setxattr, ENOATTR
 # TODO: Check whether fakeroot supports xattrs on all platforms supported below.
 # TODO: If that's the case then we can make Borg fakeroot-xattr-compatible on these as well.
 XATTR_FAKEROOT = False
-if sys.platform.startswith('linux'):
-    LD_PRELOAD = os.environ.get('LD_PRELOAD', '')
+if sys.platform.startswith("linux"):
+    LD_PRELOAD = os.environ.get("LD_PRELOAD", "")
     preloads = re.split("[ :]", LD_PRELOAD)
     for preload in preloads:
         if preload.startswith("libfakeroot"):
             env = prepare_subprocess_env(system=True)
-            fakeroot_output = subprocess.check_output(['fakeroot', '-v'], env=env)
-            fakeroot_version = parse_version(fakeroot_output.decode('ascii').split()[-1])
+            fakeroot_output = subprocess.check_output(["fakeroot", "-v"], env=env)
+            fakeroot_version = parse_version(fakeroot_output.decode("ascii").split()[-1])
             if fakeroot_version >= parse_version("1.20.2"):
                 # 1.20.2 has been confirmed to have xattr support
                 # 1.18.2 has been confirmed not to have xattr support
@@ -39,11 +39,10 @@ if sys.platform.startswith('linux'):
 
 
 def is_enabled(path=None):
-    """Determine if xattr is enabled on the filesystem
-    """
-    with tempfile.NamedTemporaryFile(dir=path, prefix='borg-tmp') as f:
+    """Determine if xattr is enabled on the filesystem"""
+    with tempfile.NamedTemporaryFile(dir=path, prefix="borg-tmp") as f:
         fd = f.fileno()
-        name, value = b'user.name', b'value'
+        name, value = b"user.name", b"value"
         try:
             setxattr(fd, name, value)
         except OSError:
@@ -80,7 +79,7 @@ def get_all(path, follow_symlinks=False):
             except OSError as e:
                 name_str = name.decode()
                 if isinstance(path, int):
-                    path_str = '<FD %d>' % path
+                    path_str = "<FD %d>" % path
                 else:
                     path_str = os.fsdecode(path)
                 if e.errno == ENOATTR:
@@ -89,8 +88,9 @@ def get_all(path, follow_symlinks=False):
                     pass
                 elif e.errno == errno.EPERM:
                     # we were not permitted to read this attribute, still can continue trying to read others
-                    logger.warning('{}: Operation not permitted when reading extended attribute {}'.format(
-                                   path_str, name_str))
+                    logger.warning(
+                        "{}: Operation not permitted when reading extended attribute {}".format(path_str, name_str)
+                    )
                 else:
                     raise
     except OSError as e:
@@ -125,21 +125,21 @@ def set_all(path, xattrs, follow_symlinks=False):
             warning = True
             k_str = k.decode()
             if isinstance(path, int):
-                path_str = '<FD %d>' % path
+                path_str = "<FD %d>" % path
             else:
                 path_str = os.fsdecode(path)
             if e.errno == errno.E2BIG:
-                err_str = 'too big for this filesystem'
+                err_str = "too big for this filesystem"
             elif e.errno == errno.ENOTSUP:
-                err_str = 'xattrs not supported on this filesystem'
+                err_str = "xattrs not supported on this filesystem"
             elif e.errno == errno.ENOSPC:
                 # ext4 reports ENOSPC when trying to set an xattr with >4kiB while ext4 can only support 4kiB xattrs
                 # (in this case, this is NOT a "disk full" error, just a ext4 limitation).
-                err_str = 'no space left on device [xattr len = %d]' % (len(v),)
+                err_str = "no space left on device [xattr len = %d]" % (len(v),)
             else:
                 # generic handler
                 # EACCES: permission denied to set this specific xattr (this may happen related to security.* keys)
                 # EPERM: operation not permitted
                 err_str = os.strerror(e.errno)
-            logger.warning('%s: when setting extended attribute %s: %s', path_str, k_str, err_str)
+            logger.warning("%s: when setting extended attribute %s: %s", path_str, k_str, err_str)
     return warning

From 2e063a9c440070b6e85b178f74f705bb8c7ea70c Mon Sep 17 00:00:00 2001
From: Thomas Waldmann <tw@waldmann-edv.de>
Date: Wed, 6 Jul 2022 15:32:50 +0200
Subject: [PATCH 115/160] docs: using black for code formatting

---
 docs/development.rst | 29 ++++++++++++++++++++++-------
 1 file changed, 22 insertions(+), 7 deletions(-)

diff --git a/docs/development.rst b/docs/development.rst
index 5051829d9..506bf7254 100644
--- a/docs/development.rst
+++ b/docs/development.rst
@@ -119,14 +119,29 @@ Code is stored on GitHub, in the `Borgbackup organization
 <https://github.com/borgbackup/borg/pulls>`_ should be sent there as
 well. See also the :ref:`support` section for more details.
 
-Style guide
------------
+Style guide / Automated Code Formatting
+---------------------------------------
 
-We generally follow `pep8
-<https://www.python.org/dev/peps/pep-0008/>`_, with 120 columns
-instead of 79. We do *not* use form-feed (``^L``) characters to
-separate sections either. Compliance is tested automatically when
-you run the tests.
+We use `black`_ for automatically formatting the code.
+
+If you work on the code, it is recommended that you run black **before each commit**
+(so that new code is always using the desired formatting and no additional commits
+are required to fix the formatting).
+
+::
+
+    pip install -r requirements.d/codestyle.txt     # everybody use same black version
+    black --check .                                 # only check, don't change
+    black .                                         # reformat the code
+
+
+The CI workflows will check the code formatting and will fail if it is not formatted correctly.
+
+When (mass-)reformatting existing code, we need to avoid ruining `git blame`, so please
+follow their `guide about avoiding ruining git blame`_:
+
+.. _black: https://black.readthedocs.io/
+.. _guide about avoiding ruining git blame: https://black.readthedocs.io/en/stable/guides/introducing_black_to_your_project.html#avoiding-ruining-git-blame
 
 Continuous Integration
 ----------------------

From ee20262fea3b5561ca556ca8af39b5da0ac36ece Mon Sep 17 00:00:00 2001
From: Thomas Waldmann <tw@waldmann-edv.de>
Date: Wed, 6 Jul 2022 15:39:51 +0200
Subject: [PATCH 116/160] add .git-blame-ignore-revs

---
 .git-blame-ignore-revs | 2 ++
 1 file changed, 2 insertions(+)
 create mode 100644 .git-blame-ignore-revs

diff --git a/.git-blame-ignore-revs b/.git-blame-ignore-revs
new file mode 100644
index 000000000..181769026
--- /dev/null
+++ b/.git-blame-ignore-revs
@@ -0,0 +1,2 @@
+# Migrate code style to Black
+7957af562d5ce8266b177039783be4dc8bdd7898

From 227ecb5b8ed49eca8212108bd82c1a8b6ed3fca6 Mon Sep 17 00:00:00 2001
From: Thomas Waldmann <tw@waldmann-edv.de>
Date: Thu, 7 Jul 2022 22:40:27 +0200
Subject: [PATCH 117/160] transform archiver module into a package

---
 src/borg/{archiver.py => archiver/__init__.py} | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 rename src/borg/{archiver.py => archiver/__init__.py} (100%)

diff --git a/src/borg/archiver.py b/src/borg/archiver/__init__.py
similarity index 100%
rename from src/borg/archiver.py
rename to src/borg/archiver/__init__.py

From 890d5950e714fdcf1f7f2881ef6a03935620766c Mon Sep 17 00:00:00 2001
From: Thomas Waldmann <tw@waldmann-edv.de>
Date: Fri, 8 Jul 2022 01:12:11 +0200
Subject: [PATCH 118/160] move debug commands to archiver.debug

---
 setup.cfg                        |   4 +-
 src/borg/archiver/__init__.py    | 957 ++-----------------------------
 src/borg/archiver/common.py      | 298 ++++++++++
 src/borg/archiver/debug.py       | 585 +++++++++++++++++++
 src/borg/remote.py               |   2 +-
 src/borg/testsuite/archiver.py   |   3 +-
 src/borg/testsuite/repository.py |   2 +-
 7 files changed, 946 insertions(+), 905 deletions(-)
 create mode 100644 src/borg/archiver/common.py
 create mode 100644 src/borg/archiver/debug.py

diff --git a/setup.cfg b/setup.cfg
index 0f7939da2..64e6a29b8 100644
--- a/setup.cfg
+++ b/setup.cfg
@@ -116,7 +116,9 @@ ignore = E226, W503, E203
 per_file_ignores =
     docs/conf.py:E121,E126,E265,E305,E401,E402
     src/borg/archive.py:E122,E125,E127,E402,E501,F401,F405,W504
-    src/borg/archiver.py:E126,E127,E128,E501,E722,E731,E741,F401,F405,W504
+    src/borg/archiver/__init__.py:E402,E501,E722,E741,F405
+    src/borg/archiver/common.py:E501,F405
+    src/borg/archiver/debug.py:F405
     src/borg/cache.py:E127,E128,E402,E501,E722,W504
     src/borg/fuse.py:E402,E501,E722,W504
     src/borg/fuse_impl.py:F811
diff --git a/src/borg/archiver/__init__.py b/src/borg/archiver/__init__.py
index ced4ce037..cd0f2ba49 100644
--- a/src/borg/archiver/__init__.py
+++ b/src/borg/archiver/__init__.py
@@ -10,7 +10,6 @@ try:
     import configparser
     import faulthandler
     import functools
-    import hashlib
     import inspect
     import itertools
     import json
@@ -25,76 +24,69 @@ try:
     import tarfile
     import textwrap
     import time
-    from binascii import unhexlify, hexlify
+    from binascii import unhexlify
     from contextlib import contextmanager
     from datetime import datetime, timedelta
     from io import TextIOWrapper
-    from struct import Struct
 
-    from .logger import create_logger, setup_logging
+    from ..logger import create_logger, setup_logging
 
     logger = create_logger()
 
-    import borg
-    from . import __version__
-    from . import helpers
-    from .checksums import crc32
-    from .archive import Archive, ArchiveChecker, ArchiveRecreater, Statistics, is_special
-    from .archive import BackupError, BackupOSError, backup_io, OsOpen, stat_update_check
-    from .archive import FilesystemObjectProcessors, TarfileObjectProcessors, MetadataCollector, ChunksProcessor
-    from .archive import has_link
-    from .cache import Cache, assert_secure, SecurityManager
-    from .constants import *  # NOQA
-    from .compress import CompressionSpec, ZLIB, ZLIB_legacy, ObfuscateSize
-    from .crypto.key import key_creator, key_argument_names, tam_required_file, tam_required
-    from .crypto.key import RepoKey, KeyfileKey, Blake2RepoKey, Blake2KeyfileKey, FlexiKey
-    from .crypto.key import AESOCBRepoKey, CHPORepoKey, Blake2AESOCBRepoKey, Blake2CHPORepoKey
-    from .crypto.key import AESOCBKeyfileKey, CHPOKeyfileKey, Blake2AESOCBKeyfileKey, Blake2CHPOKeyfileKey
-    from .crypto.keymanager import KeyManager
-    from .helpers import EXIT_SUCCESS, EXIT_WARNING, EXIT_ERROR, EXIT_SIGNAL_BASE
-    from .helpers import Error, NoManifestError, set_ec
-    from .helpers import positive_int_validator, location_validator, archivename_validator, ChunkerParams, Location
-    from .helpers import PrefixSpec, GlobSpec, NameSpec, CommentSpec, SortBySpec, FilesCacheMode
-    from .helpers import BaseFormatter, ItemFormatter, ArchiveFormatter
-    from .helpers import format_timedelta, format_file_size, parse_file_size, format_archive
-    from .helpers import remove_surrogates, bin_to_hex, prepare_dump_dict, eval_escapes
-    from .helpers import interval, prune_within, prune_split, PRUNING_PATTERNS
-    from .helpers import timestamp
-    from .helpers import get_cache_dir, os_stat
-    from .helpers import Manifest, AI_HUMAN_SORT_KEYS
-    from .helpers import HardLinkManager
-    from .helpers import StableDict
-    from .helpers import check_python, check_extension_modules
-    from .helpers import dir_is_tagged, is_slow_msgpack, is_supported_msgpack, yes, sysinfo
-    from .helpers import log_multi
-    from .helpers import signal_handler, raising_signal_handler, SigHup, SigTerm
-    from .helpers import ErrorIgnoringTextIOWrapper
-    from .helpers import ProgressIndicatorPercent
-    from .helpers import basic_json_data, json_print
-    from .helpers import replace_placeholders
-    from .helpers import ChunkIteratorFileWrapper
-    from .helpers import popen_with_error_handling, prepare_subprocess_env, create_filter_process
-    from .helpers import dash_open
-    from .helpers import umount
-    from .helpers import flags_root, flags_dir, flags_special_follow, flags_special
-    from .helpers import msgpack
-    from .helpers import sig_int
-    from .helpers import iter_separated
-    from .helpers import get_tar_filter
-    from .nanorst import rst_to_terminal
-    from .patterns import (
+    from .common import with_repository, with_other_repository, with_archive, Highlander
+    from .. import __version__
+    from .. import helpers
+    from ..archive import Archive, ArchiveChecker, ArchiveRecreater, Statistics, is_special
+    from ..archive import BackupError, BackupOSError, backup_io, OsOpen, stat_update_check
+    from ..archive import FilesystemObjectProcessors, TarfileObjectProcessors, MetadataCollector, ChunksProcessor
+    from ..cache import Cache, assert_secure, SecurityManager
+    from ..constants import *  # NOQA
+    from ..compress import CompressionSpec
+    from ..crypto.key import FlexiKey, key_creator, key_argument_names, tam_required_file
+    from ..crypto.key import AESOCBRepoKey, CHPORepoKey, Blake2AESOCBRepoKey, Blake2CHPORepoKey
+    from ..crypto.key import AESOCBKeyfileKey, CHPOKeyfileKey, Blake2AESOCBKeyfileKey, Blake2CHPOKeyfileKey
+    from ..crypto.keymanager import KeyManager
+    from ..helpers import EXIT_SUCCESS, EXIT_WARNING, EXIT_ERROR, EXIT_SIGNAL_BASE
+    from ..helpers import Error, NoManifestError, set_ec
+    from ..helpers import positive_int_validator, location_validator, archivename_validator, ChunkerParams, Location
+    from ..helpers import GlobSpec, NameSpec, CommentSpec, SortBySpec, FilesCacheMode
+    from ..helpers import BaseFormatter, ItemFormatter, ArchiveFormatter
+    from ..helpers import format_timedelta, format_file_size, parse_file_size, format_archive
+    from ..helpers import remove_surrogates, bin_to_hex, eval_escapes
+    from ..helpers import interval, prune_within, prune_split, PRUNING_PATTERNS
+    from ..helpers import timestamp
+    from ..helpers import get_cache_dir, os_stat
+    from ..helpers import Manifest, AI_HUMAN_SORT_KEYS
+    from ..helpers import HardLinkManager
+    from ..helpers import check_python, check_extension_modules
+    from ..helpers import dir_is_tagged, is_slow_msgpack, is_supported_msgpack, yes, sysinfo
+    from ..helpers import log_multi
+    from ..helpers import signal_handler, raising_signal_handler, SigHup, SigTerm
+    from ..helpers import ErrorIgnoringTextIOWrapper
+    from ..helpers import ProgressIndicatorPercent
+    from ..helpers import basic_json_data, json_print
+    from ..helpers import ChunkIteratorFileWrapper
+    from ..helpers import prepare_subprocess_env, create_filter_process
+    from ..helpers import dash_open
+    from ..helpers import umount
+    from ..helpers import flags_root, flags_dir, flags_special_follow, flags_special
+    from ..helpers import msgpack
+    from ..helpers import sig_int
+    from ..helpers import iter_separated
+    from ..helpers import get_tar_filter
+    from ..nanorst import rst_to_terminal
+    from ..patterns import (
         ArgparsePatternAction,
         ArgparseExcludeFileAction,
         ArgparsePatternFileAction,
         parse_exclude_pattern,
     )
-    from .patterns import PatternMatcher
-    from .item import Item
-    from .platform import get_flags, get_process_id, SyncFile
-    from .platform import uid2user, gid2group
-    from .remote import RepositoryServer, RemoteRepository, cache_if_remote
-    from .repository import Repository, LIST_SCAN_LIMIT, TAG_PUT, TAG_DELETE, TAG_COMMIT
-    from .selftest import selftest
+    from ..patterns import PatternMatcher
+    from ..item import Item
+    from ..platform import get_flags, SyncFile
+    from ..platform import uid2user, gid2group
+    from ..remote import RepositoryServer, RemoteRepository, cache_if_remote
+    from ..selftest import selftest
 except BaseException:
     # an unhandled exception in the try-block would cause the borg cli command to exit with rc 1 due to python's
     # default behavior, see issue #4424.
@@ -110,249 +102,6 @@ STATS_HEADER = "                       Original size    Deduplicated size"
 PURE_PYTHON_MSGPACK_WARNING = "Using a pure-python msgpack! This will result in lower performance."
 
 
-def argument(args, str_or_bool):
-    """If bool is passed, return it. If str is passed, retrieve named attribute from args."""
-    if isinstance(str_or_bool, str):
-        return getattr(args, str_or_bool)
-    if isinstance(str_or_bool, (list, tuple)):
-        return any(getattr(args, item) for item in str_or_bool)
-    return str_or_bool
-
-
-def get_repository(location, *, create, exclusive, lock_wait, lock, append_only, make_parent_dirs, storage_quota, args):
-    if location.proto == "ssh":
-        repository = RemoteRepository(
-            location,
-            create=create,
-            exclusive=exclusive,
-            lock_wait=lock_wait,
-            lock=lock,
-            append_only=append_only,
-            make_parent_dirs=make_parent_dirs,
-            args=args,
-        )
-
-    else:
-        repository = Repository(
-            location.path,
-            create=create,
-            exclusive=exclusive,
-            lock_wait=lock_wait,
-            lock=lock,
-            append_only=append_only,
-            make_parent_dirs=make_parent_dirs,
-            storage_quota=storage_quota,
-        )
-    return repository
-
-
-def compat_check(*, create, manifest, key, cache, compatibility, decorator_name):
-    if not create and (manifest or key or cache):
-        if compatibility is None:
-            raise AssertionError(f"{decorator_name} decorator used without compatibility argument")
-        if type(compatibility) is not tuple:
-            raise AssertionError(f"{decorator_name} decorator compatibility argument must be of type tuple")
-    else:
-        if compatibility is not None:
-            raise AssertionError(
-                f"{decorator_name} called with compatibility argument, " f"but would not check {compatibility!r}"
-            )
-        if create:
-            compatibility = Manifest.NO_OPERATION_CHECK
-    return compatibility
-
-
-def with_repository(
-    fake=False,
-    invert_fake=False,
-    create=False,
-    lock=True,
-    exclusive=False,
-    manifest=True,
-    cache=False,
-    secure=True,
-    compatibility=None,
-):
-    """
-    Method decorator for subcommand-handling methods: do_XYZ(self, args, repository, …)
-
-    If a parameter (where allowed) is a str the attribute named of args is used instead.
-    :param fake: (str or bool) use None instead of repository, don't do anything else
-    :param create: create repository
-    :param lock: lock repository
-    :param exclusive: (str or bool) lock repository exclusively (for writing)
-    :param manifest: load manifest and key, pass them as keyword arguments
-    :param cache: open cache, pass it as keyword argument (implies manifest)
-    :param secure: do assert_secure after loading manifest
-    :param compatibility: mandatory if not create and (manifest or cache), specifies mandatory feature categories to check
-    """
-    # Note: with_repository decorator does not have a "key" argument (yet?)
-    compatibility = compat_check(
-        create=create,
-        manifest=manifest,
-        key=manifest,
-        cache=cache,
-        compatibility=compatibility,
-        decorator_name="with_repository",
-    )
-
-    # To process the `--bypass-lock` option if specified, we need to
-    # modify `lock` inside `wrapper`. Therefore we cannot use the
-    # `nonlocal` statement to access `lock` as modifications would also
-    # affect the scope outside of `wrapper`. Subsequent calls would
-    # only see the overwritten value of `lock`, not the original one.
-    # The solution is to define a place holder variable `_lock` to
-    # propagate the value into `wrapper`.
-    _lock = lock
-
-    def decorator(method):
-        @functools.wraps(method)
-        def wrapper(self, args, **kwargs):
-            location = getattr(args, "location")
-            if not location.valid:  # location always must be given
-                raise Error("missing repository, please use --repo or BORG_REPO env var!")
-            lock = getattr(args, "lock", _lock)
-            append_only = getattr(args, "append_only", False)
-            storage_quota = getattr(args, "storage_quota", None)
-            make_parent_dirs = getattr(args, "make_parent_dirs", False)
-            if argument(args, fake) ^ invert_fake:
-                return method(self, args, repository=None, **kwargs)
-
-            repository = get_repository(
-                location,
-                create=create,
-                exclusive=argument(args, exclusive),
-                lock_wait=self.lock_wait,
-                lock=lock,
-                append_only=append_only,
-                make_parent_dirs=make_parent_dirs,
-                storage_quota=storage_quota,
-                args=args,
-            )
-
-            with repository:
-                if repository.version not in (2,):
-                    raise Error(
-                        "This borg version only accepts version 2 repos for -r/--repo. "
-                        "You can use 'borg transfer' to copy archives from old to new repos."
-                    )
-                if manifest or cache:
-                    kwargs["manifest"], kwargs["key"] = Manifest.load(repository, compatibility)
-                    if "compression" in args:
-                        kwargs["key"].compressor = args.compression.compressor
-                    if secure:
-                        assert_secure(repository, kwargs["manifest"], self.lock_wait)
-                if cache:
-                    with Cache(
-                        repository,
-                        kwargs["key"],
-                        kwargs["manifest"],
-                        progress=getattr(args, "progress", False),
-                        lock_wait=self.lock_wait,
-                        cache_mode=getattr(args, "files_cache_mode", FILES_CACHE_MODE_DISABLED),
-                        consider_part_files=getattr(args, "consider_part_files", False),
-                        iec=getattr(args, "iec", False),
-                    ) as cache_:
-                        return method(self, args, repository=repository, cache=cache_, **kwargs)
-                else:
-                    return method(self, args, repository=repository, **kwargs)
-
-        return wrapper
-
-    return decorator
-
-
-def with_other_repository(manifest=False, key=False, cache=False, compatibility=None):
-    """
-    this is a simplified version of "with_repository", just for the "other location".
-
-    the repository at the "other location" is intended to get used as a **source** (== read operations).
-    """
-
-    compatibility = compat_check(
-        create=False,
-        manifest=manifest,
-        key=key,
-        cache=cache,
-        compatibility=compatibility,
-        decorator_name="with_other_repository",
-    )
-
-    def decorator(method):
-        @functools.wraps(method)
-        def wrapper(self, args, **kwargs):
-            location = getattr(args, "other_location")
-            if not location.valid:  # nothing to do
-                return method(self, args, **kwargs)
-
-            repository = get_repository(
-                location,
-                create=False,
-                exclusive=True,
-                lock_wait=self.lock_wait,
-                lock=True,
-                append_only=False,
-                make_parent_dirs=False,
-                storage_quota=None,
-                args=args,
-            )
-
-            with repository:
-                if repository.version not in (1, 2):
-                    raise Error("This borg version only accepts version 1 or 2 repos for --other-repo.")
-                kwargs["other_repository"] = repository
-                if manifest or key or cache:
-                    manifest_, key_ = Manifest.load(repository, compatibility)
-                    assert_secure(repository, manifest_, self.lock_wait)
-                    if manifest:
-                        kwargs["other_manifest"] = manifest_
-                    if key:
-                        kwargs["other_key"] = key_
-                if cache:
-                    with Cache(
-                        repository,
-                        key_,
-                        manifest_,
-                        progress=False,
-                        lock_wait=self.lock_wait,
-                        cache_mode=getattr(args, "files_cache_mode", FILES_CACHE_MODE_DISABLED),
-                        consider_part_files=getattr(args, "consider_part_files", False),
-                        iec=getattr(args, "iec", False),
-                    ) as cache_:
-                        kwargs["other_cache"] = cache_
-                        return method(self, args, **kwargs)
-                else:
-                    return method(self, args, **kwargs)
-
-        return wrapper
-
-    return decorator
-
-
-def with_archive(method):
-    @functools.wraps(method)
-    def wrapper(self, args, repository, key, manifest, **kwargs):
-        archive_name = getattr(args, "name", None)
-        assert archive_name is not None
-        archive = Archive(
-            repository,
-            key,
-            manifest,
-            archive_name,
-            numeric_ids=getattr(args, "numeric_ids", False),
-            noflags=getattr(args, "nobsdflags", False) or getattr(args, "noflags", False),
-            noacls=getattr(args, "noacls", False),
-            noxattrs=getattr(args, "noxattrs", False),
-            cache=kwargs.get("cache"),
-            consider_part_files=args.consider_part_files,
-            log_json=args.log_json,
-            iec=args.iec,
-        )
-        return method(self, args, repository=repository, manifest=manifest, key=key, archive=archive, **kwargs)
-
-    return wrapper
-
-
 def parse_storage_quota(storage_quota):
     parsed = parse_file_size(storage_quota)
     if parsed < parse_file_size("10M"):
@@ -372,16 +121,10 @@ def get_func(args):
     raise Exception("expected func attributes not found")
 
 
-class Highlander(argparse.Action):
-    """make sure some option is only given once"""
-
-    def __call__(self, parser, namespace, values, option_string=None):
-        if getattr(namespace, self.dest, None) != self.default:
-            raise argparse.ArgumentError(self, "There can be only one.")
-        setattr(namespace, self.dest, values)
+from .debug import DebugMixIn
 
 
-class Archiver:
+class Archiver(DebugMixIn):
     def __init__(self, lock_wait=None, prog=None):
         self.exit_code = EXIT_SUCCESS
         self.lock_wait = lock_wait
@@ -1850,7 +1593,7 @@ class Archiver:
         """Mount archive or an entire repository as a FUSE filesystem"""
         # Perform these checks before opening the repository and asking for a passphrase.
 
-        from .fuse_impl import llfuse, BORG_FUSE_IMPL
+        from ..fuse_impl import llfuse, BORG_FUSE_IMPL
 
         if llfuse is None:
             self.print_error("borg mount not available: no FUSE support, BORG_FUSE_IMPL=%s." % BORG_FUSE_IMPL)
@@ -1864,7 +1607,7 @@ class Archiver:
 
     @with_repository(compatibility=(Manifest.Operation.READ,))
     def _do_mount(self, args, repository, manifest, key):
-        from .fuse import FuseOperations
+        from ..fuse import FuseOperations
 
         with cache_if_remote(repository, decrypted_cache=key) as cached_repo:
             operations = FuseOperations(key, repository, manifest, args, cached_repo)
@@ -2432,309 +2175,6 @@ class Archiver:
             if args.cache:
                 cache.close()
 
-    def do_debug_info(self, args):
-        """display system information for debugging / bug reports"""
-        print(sysinfo())
-
-        # Additional debug information
-        print("CRC implementation:", crc32.__name__)
-        print("Process ID:", get_process_id())
-        return EXIT_SUCCESS
-
-    @with_repository(compatibility=Manifest.NO_OPERATION_CHECK)
-    def do_debug_dump_archive_items(self, args, repository, manifest, key):
-        """dump (decrypted, decompressed) archive items metadata (not: data)"""
-        archive = Archive(repository, key, manifest, args.name, consider_part_files=args.consider_part_files)
-        for i, item_id in enumerate(archive.metadata.items):
-            data = key.decrypt(item_id, repository.get(item_id))
-            filename = "%06d_%s.items" % (i, bin_to_hex(item_id))
-            print("Dumping", filename)
-            with open(filename, "wb") as fd:
-                fd.write(data)
-        print("Done.")
-        return EXIT_SUCCESS
-
-    @with_repository(compatibility=Manifest.NO_OPERATION_CHECK)
-    def do_debug_dump_archive(self, args, repository, manifest, key):
-        """dump decoded archive metadata (not: data)"""
-
-        try:
-            archive_meta_orig = manifest.archives.get_raw_dict()[args.name]
-        except KeyError:
-            raise Archive.DoesNotExist(args.name)
-
-        indent = 4
-
-        def do_indent(d):
-            return textwrap.indent(json.dumps(d, indent=indent), prefix=" " * indent)
-
-        def output(fd):
-            # this outputs megabytes of data for a modest sized archive, so some manual streaming json output
-            fd.write("{\n")
-            fd.write('    "_name": ' + json.dumps(args.name) + ",\n")
-            fd.write('    "_manifest_entry":\n')
-            fd.write(do_indent(prepare_dump_dict(archive_meta_orig)))
-            fd.write(",\n")
-
-            data = key.decrypt(archive_meta_orig["id"], repository.get(archive_meta_orig["id"]))
-            archive_org_dict = msgpack.unpackb(data, object_hook=StableDict)
-
-            fd.write('    "_meta":\n')
-            fd.write(do_indent(prepare_dump_dict(archive_org_dict)))
-            fd.write(",\n")
-            fd.write('    "_items": [\n')
-
-            unpacker = msgpack.Unpacker(use_list=False, object_hook=StableDict)
-            first = True
-            for item_id in archive_org_dict["items"]:
-                data = key.decrypt(item_id, repository.get(item_id))
-                unpacker.feed(data)
-                for item in unpacker:
-                    item = prepare_dump_dict(item)
-                    if first:
-                        first = False
-                    else:
-                        fd.write(",\n")
-                    fd.write(do_indent(item))
-
-            fd.write("\n")
-            fd.write("    ]\n}\n")
-
-        with dash_open(args.path, "w") as fd:
-            output(fd)
-        return EXIT_SUCCESS
-
-    @with_repository(compatibility=Manifest.NO_OPERATION_CHECK)
-    def do_debug_dump_manifest(self, args, repository, manifest, key):
-        """dump decoded repository manifest"""
-
-        data = key.decrypt(manifest.MANIFEST_ID, repository.get(manifest.MANIFEST_ID))
-
-        meta = prepare_dump_dict(msgpack.unpackb(data, object_hook=StableDict))
-
-        with dash_open(args.path, "w") as fd:
-            json.dump(meta, fd, indent=4)
-        return EXIT_SUCCESS
-
-    @with_repository(manifest=False)
-    def do_debug_dump_repo_objs(self, args, repository):
-        """dump (decrypted, decompressed) repo objects, repo index MUST be current/correct"""
-        from .crypto.key import key_factory
-
-        def decrypt_dump(i, id, cdata, tag=None, segment=None, offset=None):
-            if cdata is not None:
-                data = key.decrypt(id, cdata)
-            else:
-                data = b""
-            tag_str = "" if tag is None else "_" + tag
-            segment_str = "_" + str(segment) if segment is not None else ""
-            offset_str = "_" + str(offset) if offset is not None else ""
-            id_str = "_" + bin_to_hex(id) if id is not None else ""
-            filename = "%08d%s%s%s%s.obj" % (i, segment_str, offset_str, tag_str, id_str)
-            print("Dumping", filename)
-            with open(filename, "wb") as fd:
-                fd.write(data)
-
-        if args.ghost:
-            # dump ghosty stuff from segment files: not yet committed objects, deleted / superseded objects, commit tags
-
-            # set up the key without depending on a manifest obj
-            for id, cdata, tag, segment, offset in repository.scan_low_level():
-                if tag == TAG_PUT:
-                    key = key_factory(repository, cdata)
-                    break
-            i = 0
-            for id, cdata, tag, segment, offset in repository.scan_low_level(segment=args.segment, offset=args.offset):
-                if tag == TAG_PUT:
-                    decrypt_dump(i, id, cdata, tag="put", segment=segment, offset=offset)
-                elif tag == TAG_DELETE:
-                    decrypt_dump(i, id, None, tag="del", segment=segment, offset=offset)
-                elif tag == TAG_COMMIT:
-                    decrypt_dump(i, None, None, tag="commit", segment=segment, offset=offset)
-                i += 1
-        else:
-            # set up the key without depending on a manifest obj
-            ids = repository.list(limit=1, marker=None)
-            cdata = repository.get(ids[0])
-            key = key_factory(repository, cdata)
-            marker = None
-            i = 0
-            while True:
-                result = repository.scan(limit=LIST_SCAN_LIMIT, marker=marker)  # must use on-disk order scanning here
-                if not result:
-                    break
-                marker = result[-1]
-                for id in result:
-                    cdata = repository.get(id)
-                    decrypt_dump(i, id, cdata)
-                    i += 1
-        print("Done.")
-        return EXIT_SUCCESS
-
-    @with_repository(manifest=False)
-    def do_debug_search_repo_objs(self, args, repository):
-        """search for byte sequences in repo objects, repo index MUST be current/correct"""
-        context = 32
-
-        def print_finding(info, wanted, data, offset):
-            before = data[offset - context : offset]
-            after = data[offset + len(wanted) : offset + len(wanted) + context]
-            print(
-                "{}: {} {} {} == {!r} {!r} {!r}".format(
-                    info, before.hex(), wanted.hex(), after.hex(), before, wanted, after
-                )
-            )
-
-        wanted = args.wanted
-        try:
-            if wanted.startswith("hex:"):
-                wanted = unhexlify(wanted[4:])
-            elif wanted.startswith("str:"):
-                wanted = wanted[4:].encode()
-            else:
-                raise ValueError("unsupported search term")
-        except (ValueError, UnicodeEncodeError):
-            wanted = None
-        if not wanted:
-            self.print_error("search term needs to be hex:123abc or str:foobar style")
-            return EXIT_ERROR
-
-        from .crypto.key import key_factory
-
-        # set up the key without depending on a manifest obj
-        ids = repository.list(limit=1, marker=None)
-        cdata = repository.get(ids[0])
-        key = key_factory(repository, cdata)
-
-        marker = None
-        last_data = b""
-        last_id = None
-        i = 0
-        while True:
-            result = repository.scan(limit=LIST_SCAN_LIMIT, marker=marker)  # must use on-disk order scanning here
-            if not result:
-                break
-            marker = result[-1]
-            for id in result:
-                cdata = repository.get(id)
-                data = key.decrypt(id, cdata)
-
-                # try to locate wanted sequence crossing the border of last_data and data
-                boundary_data = last_data[-(len(wanted) - 1) :] + data[: len(wanted) - 1]
-                if wanted in boundary_data:
-                    boundary_data = last_data[-(len(wanted) - 1 + context) :] + data[: len(wanted) - 1 + context]
-                    offset = boundary_data.find(wanted)
-                    info = "%d %s | %s" % (i, last_id.hex(), id.hex())
-                    print_finding(info, wanted, boundary_data, offset)
-
-                # try to locate wanted sequence in data
-                count = data.count(wanted)
-                if count:
-                    offset = data.find(wanted)  # only determine first occurrence's offset
-                    info = "%d %s #%d" % (i, id.hex(), count)
-                    print_finding(info, wanted, data, offset)
-
-                last_id, last_data = id, data
-                i += 1
-                if i % 10000 == 0:
-                    print("%d objects processed." % i)
-        print("Done.")
-        return EXIT_SUCCESS
-
-    @with_repository(manifest=False)
-    def do_debug_get_obj(self, args, repository):
-        """get object contents from the repository and write it into file"""
-        hex_id = args.id
-        try:
-            id = unhexlify(hex_id)
-        except ValueError:
-            print("object id %s is invalid." % hex_id)
-        else:
-            try:
-                data = repository.get(id)
-            except Repository.ObjectNotFound:
-                print("object %s not found." % hex_id)
-            else:
-                with open(args.path, "wb") as f:
-                    f.write(data)
-                print("object %s fetched." % hex_id)
-        return EXIT_SUCCESS
-
-    @with_repository(manifest=False, exclusive=True)
-    def do_debug_put_obj(self, args, repository):
-        """put file(s) contents into the repository"""
-        for path in args.paths:
-            with open(path, "rb") as f:
-                data = f.read()
-            h = hashlib.sha256(data)  # XXX hardcoded
-            repository.put(h.digest(), data)
-            print("object %s put." % h.hexdigest())
-        repository.commit(compact=False)
-        return EXIT_SUCCESS
-
-    @with_repository(manifest=False, exclusive=True)
-    def do_debug_delete_obj(self, args, repository):
-        """delete the objects with the given IDs from the repo"""
-        modified = False
-        for hex_id in args.ids:
-            try:
-                id = unhexlify(hex_id)
-            except ValueError:
-                print("object id %s is invalid." % hex_id)
-            else:
-                try:
-                    repository.delete(id)
-                    modified = True
-                    print("object %s deleted." % hex_id)
-                except Repository.ObjectNotFound:
-                    print("object %s not found." % hex_id)
-        if modified:
-            repository.commit(compact=False)
-        print("Done.")
-        return EXIT_SUCCESS
-
-    @with_repository(manifest=False, exclusive=True, cache=True, compatibility=Manifest.NO_OPERATION_CHECK)
-    def do_debug_refcount_obj(self, args, repository, manifest, key, cache):
-        """display refcounts for the objects with the given IDs"""
-        for hex_id in args.ids:
-            try:
-                id = unhexlify(hex_id)
-            except ValueError:
-                print("object id %s is invalid." % hex_id)
-            else:
-                try:
-                    refcount = cache.chunks[id][0]
-                    print("object %s has %d referrers [info from chunks cache]." % (hex_id, refcount))
-                except KeyError:
-                    print("object %s not found [info from chunks cache]." % hex_id)
-        return EXIT_SUCCESS
-
-    @with_repository(manifest=False, exclusive=True)
-    def do_debug_dump_hints(self, args, repository):
-        """dump repository hints"""
-        if not repository._active_txn:
-            repository.prepare_txn(repository.get_transaction_id())
-        try:
-            hints = dict(
-                segments=repository.segments,
-                compact=repository.compact,
-                storage_quota_use=repository.storage_quota_use,
-                shadow_index={hexlify(k).decode(): v for k, v in repository.shadow_index.items()},
-            )
-            with dash_open(args.path, "w") as fd:
-                json.dump(hints, fd, indent=4)
-        finally:
-            repository.rollback()
-        return EXIT_SUCCESS
-
-    def do_debug_convert_profile(self, args):
-        """convert Borg profile to Python profile"""
-        import marshal
-
-        with args.output, args.input:
-            marshal.dump(msgpack.unpack(args.input, use_list=False, raw=False), args.output)
-        return EXIT_SUCCESS
-
     @with_repository(lock=False, manifest=False)
     def do_break_lock(self, args, repository):
         """Break the repository lock (e.g. in case it was left by a dead borg."""
@@ -3298,31 +2738,8 @@ class Archiver:
                 setattr(args, dest, option_value)
 
     def build_parser(self):
-        # You can use :ref:`xyz` in the following usage pages. However, for plain-text view,
-        # e.g. through "borg ... --help", define a substitution for the reference here.
-        # It will replace the entire :ref:`foo` verbatim.
-        rst_plain_text_references = {
-            "a_status_oddity": '"I am seeing ‘A’ (added) status for a unchanged file!?"',
-            "separate_compaction": '"Separate compaction"',
-            "list_item_flags": '"Item flags"',
-            "borg_patterns": '"borg help patterns"',
-            "borg_placeholders": '"borg help placeholders"',
-            "key_files": "Internals -> Data structures and file formats -> Key files",
-            "borg_key_export": "borg key export --help",
-        }
 
-        def process_epilog(epilog):
-            epilog = textwrap.dedent(epilog).splitlines()
-            try:
-                mode = borg.doc_mode
-            except AttributeError:
-                mode = "command-line"
-            if mode in ("command-line", "build_usage"):
-                epilog = [line for line in epilog if not line.startswith(".. man")]
-            epilog = "\n".join(epilog)
-            if mode == "command-line":
-                epilog = rst_to_terminal(epilog, rst_plain_text_references)
-            return epilog
+        from .common import process_epilog
 
         def define_common_options(add_common_option):
             add_common_option("-h", "--help", action="help", help="show this help message and exit")
@@ -4391,267 +3808,7 @@ class Archiver:
         subparser.add_argument("name", metavar="NAME", type=NameSpec, help="specify the archive name")
         subparser.add_argument("paths", metavar="PATH", nargs="*", type=str, help="paths to archive")
 
-        # borg debug
-        debug_epilog = process_epilog(
-            """
-        These commands are not intended for normal use and potentially very
-        dangerous if used incorrectly.
-
-        They exist to improve debugging capabilities without direct system access, e.g.
-        in case you ever run into some severe malfunction. Use them only if you know
-        what you are doing or if a trusted developer tells you what to do."""
-        )
-
-        subparser = subparsers.add_parser(
-            "debug",
-            parents=[mid_common_parser],
-            add_help=False,
-            description="debugging command (not intended for normal use)",
-            epilog=debug_epilog,
-            formatter_class=argparse.RawDescriptionHelpFormatter,
-            help="debugging command (not intended for normal use)",
-        )
-
-        debug_parsers = subparser.add_subparsers(title="required arguments", metavar="<command>")
-        subparser.set_defaults(fallback_func=functools.partial(self.do_subcommand_help, subparser))
-
-        debug_info_epilog = process_epilog(
-            """
-        This command displays some system information that might be useful for bug
-        reports and debugging problems. If a traceback happens, this information is
-        already appended at the end of the traceback.
-        """
-        )
-        subparser = debug_parsers.add_parser(
-            "info",
-            parents=[common_parser],
-            add_help=False,
-            description=self.do_debug_info.__doc__,
-            epilog=debug_info_epilog,
-            formatter_class=argparse.RawDescriptionHelpFormatter,
-            help="show system infos for debugging / bug reports (debug)",
-        )
-        subparser.set_defaults(func=self.do_debug_info)
-
-        debug_dump_archive_items_epilog = process_epilog(
-            """
-        This command dumps raw (but decrypted and decompressed) archive items (only metadata) to files.
-        """
-        )
-        subparser = debug_parsers.add_parser(
-            "dump-archive-items",
-            parents=[common_parser],
-            add_help=False,
-            description=self.do_debug_dump_archive_items.__doc__,
-            epilog=debug_dump_archive_items_epilog,
-            formatter_class=argparse.RawDescriptionHelpFormatter,
-            help="dump archive items (metadata) (debug)",
-        )
-        subparser.set_defaults(func=self.do_debug_dump_archive_items)
-        subparser.add_argument("name", metavar="NAME", type=NameSpec, help="specify the archive name")
-
-        debug_dump_archive_epilog = process_epilog(
-            """
-        This command dumps all metadata of an archive in a decoded form to a file.
-        """
-        )
-        subparser = debug_parsers.add_parser(
-            "dump-archive",
-            parents=[common_parser],
-            add_help=False,
-            description=self.do_debug_dump_archive.__doc__,
-            epilog=debug_dump_archive_epilog,
-            formatter_class=argparse.RawDescriptionHelpFormatter,
-            help="dump decoded archive metadata (debug)",
-        )
-        subparser.set_defaults(func=self.do_debug_dump_archive)
-        subparser.add_argument("name", metavar="NAME", type=NameSpec, help="specify the archive name")
-        subparser.add_argument("path", metavar="PATH", type=str, help="file to dump data into")
-
-        debug_dump_manifest_epilog = process_epilog(
-            """
-        This command dumps manifest metadata of a repository in a decoded form to a file.
-        """
-        )
-        subparser = debug_parsers.add_parser(
-            "dump-manifest",
-            parents=[common_parser],
-            add_help=False,
-            description=self.do_debug_dump_manifest.__doc__,
-            epilog=debug_dump_manifest_epilog,
-            formatter_class=argparse.RawDescriptionHelpFormatter,
-            help="dump decoded repository metadata (debug)",
-        )
-        subparser.set_defaults(func=self.do_debug_dump_manifest)
-        subparser.add_argument("path", metavar="PATH", type=str, help="file to dump data into")
-
-        debug_dump_repo_objs_epilog = process_epilog(
-            """
-        This command dumps raw (but decrypted and decompressed) repo objects to files.
-        """
-        )
-        subparser = debug_parsers.add_parser(
-            "dump-repo-objs",
-            parents=[common_parser],
-            add_help=False,
-            description=self.do_debug_dump_repo_objs.__doc__,
-            epilog=debug_dump_repo_objs_epilog,
-            formatter_class=argparse.RawDescriptionHelpFormatter,
-            help="dump repo objects (debug)",
-        )
-        subparser.set_defaults(func=self.do_debug_dump_repo_objs)
-        subparser.add_argument(
-            "--ghost",
-            dest="ghost",
-            action="store_true",
-            help="dump all segment file contents, including deleted/uncommitted objects and commits.",
-        )
-        subparser.add_argument(
-            "--segment",
-            metavar="SEG",
-            dest="segment",
-            default=None,
-            type=positive_int_validator,
-            help="used together with --ghost: limit processing to given segment.",
-        )
-        subparser.add_argument(
-            "--offset",
-            metavar="OFFS",
-            dest="offset",
-            default=None,
-            type=positive_int_validator,
-            help="used together with --ghost: limit processing to given offset.",
-        )
-
-        debug_search_repo_objs_epilog = process_epilog(
-            """
-        This command searches raw (but decrypted and decompressed) repo objects for a specific bytes sequence.
-        """
-        )
-        subparser = debug_parsers.add_parser(
-            "search-repo-objs",
-            parents=[common_parser],
-            add_help=False,
-            description=self.do_debug_search_repo_objs.__doc__,
-            epilog=debug_search_repo_objs_epilog,
-            formatter_class=argparse.RawDescriptionHelpFormatter,
-            help="search repo objects (debug)",
-        )
-        subparser.set_defaults(func=self.do_debug_search_repo_objs)
-        subparser.add_argument(
-            "wanted",
-            metavar="WANTED",
-            type=str,
-            help="term to search the repo for, either 0x1234abcd hex term or a string",
-        )
-
-        debug_get_obj_epilog = process_epilog(
-            """
-        This command gets an object from the repository.
-        """
-        )
-        subparser = debug_parsers.add_parser(
-            "get-obj",
-            parents=[common_parser],
-            add_help=False,
-            description=self.do_debug_get_obj.__doc__,
-            epilog=debug_get_obj_epilog,
-            formatter_class=argparse.RawDescriptionHelpFormatter,
-            help="get object from repository (debug)",
-        )
-        subparser.set_defaults(func=self.do_debug_get_obj)
-        subparser.add_argument("id", metavar="ID", type=str, help="hex object ID to get from the repo")
-        subparser.add_argument("path", metavar="PATH", type=str, help="file to write object data into")
-
-        debug_put_obj_epilog = process_epilog(
-            """
-        This command puts objects into the repository.
-        """
-        )
-        subparser = debug_parsers.add_parser(
-            "put-obj",
-            parents=[common_parser],
-            add_help=False,
-            description=self.do_debug_put_obj.__doc__,
-            epilog=debug_put_obj_epilog,
-            formatter_class=argparse.RawDescriptionHelpFormatter,
-            help="put object to repository (debug)",
-        )
-        subparser.set_defaults(func=self.do_debug_put_obj)
-        subparser.add_argument(
-            "paths", metavar="PATH", nargs="+", type=str, help="file(s) to read and create object(s) from"
-        )
-
-        debug_delete_obj_epilog = process_epilog(
-            """
-        This command deletes objects from the repository.
-        """
-        )
-        subparser = debug_parsers.add_parser(
-            "delete-obj",
-            parents=[common_parser],
-            add_help=False,
-            description=self.do_debug_delete_obj.__doc__,
-            epilog=debug_delete_obj_epilog,
-            formatter_class=argparse.RawDescriptionHelpFormatter,
-            help="delete object from repository (debug)",
-        )
-        subparser.set_defaults(func=self.do_debug_delete_obj)
-        subparser.add_argument(
-            "ids", metavar="IDs", nargs="+", type=str, help="hex object ID(s) to delete from the repo"
-        )
-
-        debug_refcount_obj_epilog = process_epilog(
-            """
-        This command displays the reference count for objects from the repository.
-        """
-        )
-        subparser = debug_parsers.add_parser(
-            "refcount-obj",
-            parents=[common_parser],
-            add_help=False,
-            description=self.do_debug_refcount_obj.__doc__,
-            epilog=debug_refcount_obj_epilog,
-            formatter_class=argparse.RawDescriptionHelpFormatter,
-            help="show refcount for object from repository (debug)",
-        )
-        subparser.set_defaults(func=self.do_debug_refcount_obj)
-        subparser.add_argument("ids", metavar="IDs", nargs="+", type=str, help="hex object ID(s) to show refcounts for")
-
-        debug_dump_hints_epilog = process_epilog(
-            """
-        This command dumps the repository hints data.
-        """
-        )
-        subparser = debug_parsers.add_parser(
-            "dump-hints",
-            parents=[common_parser],
-            add_help=False,
-            description=self.do_debug_dump_hints.__doc__,
-            epilog=debug_dump_hints_epilog,
-            formatter_class=argparse.RawDescriptionHelpFormatter,
-            help="dump repo hints (debug)",
-        )
-        subparser.set_defaults(func=self.do_debug_dump_hints)
-        subparser.add_argument("path", metavar="PATH", type=str, help="file to dump data into")
-
-        debug_convert_profile_epilog = process_epilog(
-            """
-        Convert a Borg profile to a Python cProfile compatible profile.
-        """
-        )
-        subparser = debug_parsers.add_parser(
-            "convert-profile",
-            parents=[common_parser],
-            add_help=False,
-            description=self.do_debug_convert_profile.__doc__,
-            epilog=debug_convert_profile_epilog,
-            formatter_class=argparse.RawDescriptionHelpFormatter,
-            help="convert Borg profile to Python profile (debug)",
-        )
-        subparser.set_defaults(func=self.do_debug_convert_profile)
-        subparser.add_argument("input", metavar="INPUT", type=argparse.FileType("rb"), help="Borg profile")
-        subparser.add_argument("output", metavar="OUTPUT", type=argparse.FileType("wb"), help="Output file")
+        self.build_parser_debug(subparsers, common_parser, mid_common_parser)
 
         # borg rdelete
         rdelete_epilog = process_epilog(
diff --git a/src/borg/archiver/common.py b/src/borg/archiver/common.py
new file mode 100644
index 000000000..49d1c8a9f
--- /dev/null
+++ b/src/borg/archiver/common.py
@@ -0,0 +1,298 @@
+import argparse
+import functools
+import textwrap
+
+import borg
+from ..archive import Archive
+from ..constants import *  # NOQA
+from ..cache import Cache, assert_secure
+from ..helpers import Error
+from ..helpers import Manifest
+from ..remote import RemoteRepository
+from ..repository import Repository
+
+from ..nanorst import rst_to_terminal
+
+from ..logger import create_logger
+
+logger = create_logger(__name__)
+
+
+def argument(args, str_or_bool):
+    """If bool is passed, return it. If str is passed, retrieve named attribute from args."""
+    if isinstance(str_or_bool, str):
+        return getattr(args, str_or_bool)
+    if isinstance(str_or_bool, (list, tuple)):
+        return any(getattr(args, item) for item in str_or_bool)
+    return str_or_bool
+
+
+def get_repository(location, *, create, exclusive, lock_wait, lock, append_only, make_parent_dirs, storage_quota, args):
+    if location.proto == "ssh":
+        repository = RemoteRepository(
+            location,
+            create=create,
+            exclusive=exclusive,
+            lock_wait=lock_wait,
+            lock=lock,
+            append_only=append_only,
+            make_parent_dirs=make_parent_dirs,
+            args=args,
+        )
+
+    else:
+        repository = Repository(
+            location.path,
+            create=create,
+            exclusive=exclusive,
+            lock_wait=lock_wait,
+            lock=lock,
+            append_only=append_only,
+            make_parent_dirs=make_parent_dirs,
+            storage_quota=storage_quota,
+        )
+    return repository
+
+
+def compat_check(*, create, manifest, key, cache, compatibility, decorator_name):
+    if not create and (manifest or key or cache):
+        if compatibility is None:
+            raise AssertionError(f"{decorator_name} decorator used without compatibility argument")
+        if type(compatibility) is not tuple:
+            raise AssertionError(f"{decorator_name} decorator compatibility argument must be of type tuple")
+    else:
+        if compatibility is not None:
+            raise AssertionError(
+                f"{decorator_name} called with compatibility argument, " f"but would not check {compatibility!r}"
+            )
+        if create:
+            compatibility = Manifest.NO_OPERATION_CHECK
+    return compatibility
+
+
+def with_repository(
+    fake=False,
+    invert_fake=False,
+    create=False,
+    lock=True,
+    exclusive=False,
+    manifest=True,
+    cache=False,
+    secure=True,
+    compatibility=None,
+):
+    """
+    Method decorator for subcommand-handling methods: do_XYZ(self, args, repository, …)
+
+    If a parameter (where allowed) is a str the attribute named of args is used instead.
+    :param fake: (str or bool) use None instead of repository, don't do anything else
+    :param create: create repository
+    :param lock: lock repository
+    :param exclusive: (str or bool) lock repository exclusively (for writing)
+    :param manifest: load manifest and key, pass them as keyword arguments
+    :param cache: open cache, pass it as keyword argument (implies manifest)
+    :param secure: do assert_secure after loading manifest
+    :param compatibility: mandatory if not create and (manifest or cache), specifies mandatory feature categories to check
+    """
+    # Note: with_repository decorator does not have a "key" argument (yet?)
+    compatibility = compat_check(
+        create=create,
+        manifest=manifest,
+        key=manifest,
+        cache=cache,
+        compatibility=compatibility,
+        decorator_name="with_repository",
+    )
+
+    # To process the `--bypass-lock` option if specified, we need to
+    # modify `lock` inside `wrapper`. Therefore we cannot use the
+    # `nonlocal` statement to access `lock` as modifications would also
+    # affect the scope outside of `wrapper`. Subsequent calls would
+    # only see the overwritten value of `lock`, not the original one.
+    # The solution is to define a place holder variable `_lock` to
+    # propagate the value into `wrapper`.
+    _lock = lock
+
+    def decorator(method):
+        @functools.wraps(method)
+        def wrapper(self, args, **kwargs):
+            location = getattr(args, "location")
+            if not location.valid:  # location always must be given
+                raise Error("missing repository, please use --repo or BORG_REPO env var!")
+            lock = getattr(args, "lock", _lock)
+            append_only = getattr(args, "append_only", False)
+            storage_quota = getattr(args, "storage_quota", None)
+            make_parent_dirs = getattr(args, "make_parent_dirs", False)
+            if argument(args, fake) ^ invert_fake:
+                return method(self, args, repository=None, **kwargs)
+
+            repository = get_repository(
+                location,
+                create=create,
+                exclusive=argument(args, exclusive),
+                lock_wait=self.lock_wait,
+                lock=lock,
+                append_only=append_only,
+                make_parent_dirs=make_parent_dirs,
+                storage_quota=storage_quota,
+                args=args,
+            )
+
+            with repository:
+                if repository.version not in (2,):
+                    raise Error(
+                        "This borg version only accepts version 2 repos for -r/--repo. "
+                        "You can use 'borg transfer' to copy archives from old to new repos."
+                    )
+                if manifest or cache:
+                    kwargs["manifest"], kwargs["key"] = Manifest.load(repository, compatibility)
+                    if "compression" in args:
+                        kwargs["key"].compressor = args.compression.compressor
+                    if secure:
+                        assert_secure(repository, kwargs["manifest"], self.lock_wait)
+                if cache:
+                    with Cache(
+                        repository,
+                        kwargs["key"],
+                        kwargs["manifest"],
+                        progress=getattr(args, "progress", False),
+                        lock_wait=self.lock_wait,
+                        cache_mode=getattr(args, "files_cache_mode", FILES_CACHE_MODE_DISABLED),
+                        consider_part_files=getattr(args, "consider_part_files", False),
+                        iec=getattr(args, "iec", False),
+                    ) as cache_:
+                        return method(self, args, repository=repository, cache=cache_, **kwargs)
+                else:
+                    return method(self, args, repository=repository, **kwargs)
+
+        return wrapper
+
+    return decorator
+
+
+def with_other_repository(manifest=False, key=False, cache=False, compatibility=None):
+    """
+    this is a simplified version of "with_repository", just for the "other location".
+
+    the repository at the "other location" is intended to get used as a **source** (== read operations).
+    """
+
+    compatibility = compat_check(
+        create=False,
+        manifest=manifest,
+        key=key,
+        cache=cache,
+        compatibility=compatibility,
+        decorator_name="with_other_repository",
+    )
+
+    def decorator(method):
+        @functools.wraps(method)
+        def wrapper(self, args, **kwargs):
+            location = getattr(args, "other_location")
+            if not location.valid:  # nothing to do
+                return method(self, args, **kwargs)
+
+            repository = get_repository(
+                location,
+                create=False,
+                exclusive=True,
+                lock_wait=self.lock_wait,
+                lock=True,
+                append_only=False,
+                make_parent_dirs=False,
+                storage_quota=None,
+                args=args,
+            )
+
+            with repository:
+                if repository.version not in (1, 2):
+                    raise Error("This borg version only accepts version 1 or 2 repos for --other-repo.")
+                kwargs["other_repository"] = repository
+                if manifest or key or cache:
+                    manifest_, key_ = Manifest.load(repository, compatibility)
+                    assert_secure(repository, manifest_, self.lock_wait)
+                    if manifest:
+                        kwargs["other_manifest"] = manifest_
+                    if key:
+                        kwargs["other_key"] = key_
+                if cache:
+                    with Cache(
+                        repository,
+                        key_,
+                        manifest_,
+                        progress=False,
+                        lock_wait=self.lock_wait,
+                        cache_mode=getattr(args, "files_cache_mode", FILES_CACHE_MODE_DISABLED),
+                        consider_part_files=getattr(args, "consider_part_files", False),
+                        iec=getattr(args, "iec", False),
+                    ) as cache_:
+                        kwargs["other_cache"] = cache_
+                        return method(self, args, **kwargs)
+                else:
+                    return method(self, args, **kwargs)
+
+        return wrapper
+
+    return decorator
+
+
+def with_archive(method):
+    @functools.wraps(method)
+    def wrapper(self, args, repository, key, manifest, **kwargs):
+        archive_name = getattr(args, "name", None)
+        assert archive_name is not None
+        archive = Archive(
+            repository,
+            key,
+            manifest,
+            archive_name,
+            numeric_ids=getattr(args, "numeric_ids", False),
+            noflags=getattr(args, "nobsdflags", False) or getattr(args, "noflags", False),
+            noacls=getattr(args, "noacls", False),
+            noxattrs=getattr(args, "noxattrs", False),
+            cache=kwargs.get("cache"),
+            consider_part_files=args.consider_part_files,
+            log_json=args.log_json,
+            iec=args.iec,
+        )
+        return method(self, args, repository=repository, manifest=manifest, key=key, archive=archive, **kwargs)
+
+    return wrapper
+
+
+class Highlander(argparse.Action):
+    """make sure some option is only given once"""
+
+    def __call__(self, parser, namespace, values, option_string=None):
+        if getattr(namespace, self.dest, None) != self.default:
+            raise argparse.ArgumentError(self, "There can be only one.")
+        setattr(namespace, self.dest, values)
+
+
+# You can use :ref:`xyz` in the following usage pages. However, for plain-text view,
+# e.g. through "borg ... --help", define a substitution for the reference here.
+# It will replace the entire :ref:`foo` verbatim.
+rst_plain_text_references = {
+    "a_status_oddity": '"I am seeing ‘A’ (added) status for a unchanged file!?"',
+    "separate_compaction": '"Separate compaction"',
+    "list_item_flags": '"Item flags"',
+    "borg_patterns": '"borg help patterns"',
+    "borg_placeholders": '"borg help placeholders"',
+    "key_files": "Internals -> Data structures and file formats -> Key files",
+    "borg_key_export": "borg key export --help",
+}
+
+
+def process_epilog(epilog):
+    epilog = textwrap.dedent(epilog).splitlines()
+    try:
+        mode = borg.doc_mode
+    except AttributeError:
+        mode = "command-line"
+    if mode in ("command-line", "build_usage"):
+        epilog = [line for line in epilog if not line.startswith(".. man")]
+    epilog = "\n".join(epilog)
+    if mode == "command-line":
+        epilog = rst_to_terminal(epilog, rst_plain_text_references)
+    return epilog
diff --git a/src/borg/archiver/debug.py b/src/borg/archiver/debug.py
new file mode 100644
index 000000000..bc68090f3
--- /dev/null
+++ b/src/borg/archiver/debug.py
@@ -0,0 +1,585 @@
+import argparse
+from binascii import unhexlify, hexlify
+import functools
+import hashlib
+import json
+import textwrap
+
+from ..archive import Archive
+from ..constants import *  # NOQA
+from ..helpers import msgpack
+from ..helpers import sysinfo
+from ..helpers import bin_to_hex, prepare_dump_dict
+from ..helpers import Manifest
+from ..helpers import dash_open
+from ..helpers import StableDict
+from ..helpers import positive_int_validator, NameSpec
+from ..platform import get_process_id
+from ..repository import Repository, LIST_SCAN_LIMIT, TAG_PUT, TAG_DELETE, TAG_COMMIT
+
+from .common import with_repository
+from .common import process_epilog
+
+
+class DebugMixIn:
+    def do_debug_info(self, args):
+        """display system information for debugging / bug reports"""
+        print(sysinfo())
+        print("Process ID:", get_process_id())
+        return EXIT_SUCCESS
+
+    @with_repository(compatibility=Manifest.NO_OPERATION_CHECK)
+    def do_debug_dump_archive_items(self, args, repository, manifest, key):
+        """dump (decrypted, decompressed) archive items metadata (not: data)"""
+        archive = Archive(repository, key, manifest, args.name, consider_part_files=args.consider_part_files)
+        for i, item_id in enumerate(archive.metadata.items):
+            data = key.decrypt(item_id, repository.get(item_id))
+            filename = "%06d_%s.items" % (i, bin_to_hex(item_id))
+            print("Dumping", filename)
+            with open(filename, "wb") as fd:
+                fd.write(data)
+        print("Done.")
+        return EXIT_SUCCESS
+
+    @with_repository(compatibility=Manifest.NO_OPERATION_CHECK)
+    def do_debug_dump_archive(self, args, repository, manifest, key):
+        """dump decoded archive metadata (not: data)"""
+        try:
+            archive_meta_orig = manifest.archives.get_raw_dict()[args.name]
+        except KeyError:
+            raise Archive.DoesNotExist(args.name)
+
+        indent = 4
+
+        def do_indent(d):
+            return textwrap.indent(json.dumps(d, indent=indent), prefix=" " * indent)
+
+        def output(fd):
+            # this outputs megabytes of data for a modest sized archive, so some manual streaming json output
+            fd.write("{\n")
+            fd.write('    "_name": ' + json.dumps(args.name) + ",\n")
+            fd.write('    "_manifest_entry":\n')
+            fd.write(do_indent(prepare_dump_dict(archive_meta_orig)))
+            fd.write(",\n")
+
+            data = key.decrypt(archive_meta_orig["id"], repository.get(archive_meta_orig["id"]))
+            archive_org_dict = msgpack.unpackb(data, object_hook=StableDict)
+
+            fd.write('    "_meta":\n')
+            fd.write(do_indent(prepare_dump_dict(archive_org_dict)))
+            fd.write(",\n")
+            fd.write('    "_items": [\n')
+
+            unpacker = msgpack.Unpacker(use_list=False, object_hook=StableDict)
+            first = True
+            for item_id in archive_org_dict["items"]:
+                data = key.decrypt(item_id, repository.get(item_id))
+                unpacker.feed(data)
+                for item in unpacker:
+                    item = prepare_dump_dict(item)
+                    if first:
+                        first = False
+                    else:
+                        fd.write(",\n")
+                    fd.write(do_indent(item))
+
+            fd.write("\n")
+            fd.write("    ]\n}\n")
+
+        with dash_open(args.path, "w") as fd:
+            output(fd)
+        return EXIT_SUCCESS
+
+    @with_repository(compatibility=Manifest.NO_OPERATION_CHECK)
+    def do_debug_dump_manifest(self, args, repository, manifest, key):
+        """dump decoded repository manifest"""
+
+        data = key.decrypt(manifest.MANIFEST_ID, repository.get(manifest.MANIFEST_ID))
+
+        meta = prepare_dump_dict(msgpack.unpackb(data, object_hook=StableDict))
+
+        with dash_open(args.path, "w") as fd:
+            json.dump(meta, fd, indent=4)
+        return EXIT_SUCCESS
+
+    @with_repository(manifest=False)
+    def do_debug_dump_repo_objs(self, args, repository):
+        """dump (decrypted, decompressed) repo objects, repo index MUST be current/correct"""
+        from ..crypto.key import key_factory
+
+        def decrypt_dump(i, id, cdata, tag=None, segment=None, offset=None):
+            if cdata is not None:
+                data = key.decrypt(id, cdata)
+            else:
+                data = b""
+            tag_str = "" if tag is None else "_" + tag
+            segment_str = "_" + str(segment) if segment is not None else ""
+            offset_str = "_" + str(offset) if offset is not None else ""
+            id_str = "_" + bin_to_hex(id) if id is not None else ""
+            filename = "%08d%s%s%s%s.obj" % (i, segment_str, offset_str, tag_str, id_str)
+            print("Dumping", filename)
+            with open(filename, "wb") as fd:
+                fd.write(data)
+
+        if args.ghost:
+            # dump ghosty stuff from segment files: not yet committed objects, deleted / superseded objects, commit tags
+
+            # set up the key without depending on a manifest obj
+            for id, cdata, tag, segment, offset in repository.scan_low_level():
+                if tag == TAG_PUT:
+                    key = key_factory(repository, cdata)
+                    break
+            i = 0
+            for id, cdata, tag, segment, offset in repository.scan_low_level(segment=args.segment, offset=args.offset):
+                if tag == TAG_PUT:
+                    decrypt_dump(i, id, cdata, tag="put", segment=segment, offset=offset)
+                elif tag == TAG_DELETE:
+                    decrypt_dump(i, id, None, tag="del", segment=segment, offset=offset)
+                elif tag == TAG_COMMIT:
+                    decrypt_dump(i, None, None, tag="commit", segment=segment, offset=offset)
+                i += 1
+        else:
+            # set up the key without depending on a manifest obj
+            ids = repository.list(limit=1, marker=None)
+            cdata = repository.get(ids[0])
+            key = key_factory(repository, cdata)
+            marker = None
+            i = 0
+            while True:
+                result = repository.scan(limit=LIST_SCAN_LIMIT, marker=marker)  # must use on-disk order scanning here
+                if not result:
+                    break
+                marker = result[-1]
+                for id in result:
+                    cdata = repository.get(id)
+                    decrypt_dump(i, id, cdata)
+                    i += 1
+        print("Done.")
+        return EXIT_SUCCESS
+
+    @with_repository(manifest=False)
+    def do_debug_search_repo_objs(self, args, repository):
+        """search for byte sequences in repo objects, repo index MUST be current/correct"""
+        context = 32
+
+        def print_finding(info, wanted, data, offset):
+            before = data[offset - context : offset]
+            after = data[offset + len(wanted) : offset + len(wanted) + context]
+            print(
+                "{}: {} {} {} == {!r} {!r} {!r}".format(
+                    info, before.hex(), wanted.hex(), after.hex(), before, wanted, after
+                )
+            )
+
+        wanted = args.wanted
+        try:
+            if wanted.startswith("hex:"):
+                wanted = unhexlify(wanted[4:])
+            elif wanted.startswith("str:"):
+                wanted = wanted[4:].encode()
+            else:
+                raise ValueError("unsupported search term")
+        except (ValueError, UnicodeEncodeError):
+            wanted = None
+        if not wanted:
+            self.print_error("search term needs to be hex:123abc or str:foobar style")
+            return EXIT_ERROR
+
+        from ..crypto.key import key_factory
+
+        # set up the key without depending on a manifest obj
+        ids = repository.list(limit=1, marker=None)
+        cdata = repository.get(ids[0])
+        key = key_factory(repository, cdata)
+
+        marker = None
+        last_data = b""
+        last_id = None
+        i = 0
+        while True:
+            result = repository.scan(limit=LIST_SCAN_LIMIT, marker=marker)  # must use on-disk order scanning here
+            if not result:
+                break
+            marker = result[-1]
+            for id in result:
+                cdata = repository.get(id)
+                data = key.decrypt(id, cdata)
+
+                # try to locate wanted sequence crossing the border of last_data and data
+                boundary_data = last_data[-(len(wanted) - 1) :] + data[: len(wanted) - 1]
+                if wanted in boundary_data:
+                    boundary_data = last_data[-(len(wanted) - 1 + context) :] + data[: len(wanted) - 1 + context]
+                    offset = boundary_data.find(wanted)
+                    info = "%d %s | %s" % (i, last_id.hex(), id.hex())
+                    print_finding(info, wanted, boundary_data, offset)
+
+                # try to locate wanted sequence in data
+                count = data.count(wanted)
+                if count:
+                    offset = data.find(wanted)  # only determine first occurrence's offset
+                    info = "%d %s #%d" % (i, id.hex(), count)
+                    print_finding(info, wanted, data, offset)
+
+                last_id, last_data = id, data
+                i += 1
+                if i % 10000 == 0:
+                    print("%d objects processed." % i)
+        print("Done.")
+        return EXIT_SUCCESS
+
+    @with_repository(manifest=False)
+    def do_debug_get_obj(self, args, repository):
+        """get object contents from the repository and write it into file"""
+        hex_id = args.id
+        try:
+            id = unhexlify(hex_id)
+        except ValueError:
+            print("object id %s is invalid." % hex_id)
+        else:
+            try:
+                data = repository.get(id)
+            except Repository.ObjectNotFound:
+                print("object %s not found." % hex_id)
+            else:
+                with open(args.path, "wb") as f:
+                    f.write(data)
+                print("object %s fetched." % hex_id)
+        return EXIT_SUCCESS
+
+    @with_repository(manifest=False, exclusive=True)
+    def do_debug_put_obj(self, args, repository):
+        """put file(s) contents into the repository"""
+        for path in args.paths:
+            with open(path, "rb") as f:
+                data = f.read()
+            h = hashlib.sha256(data)  # XXX hardcoded
+            repository.put(h.digest(), data)
+            print("object %s put." % h.hexdigest())
+        repository.commit(compact=False)
+        return EXIT_SUCCESS
+
+    @with_repository(manifest=False, exclusive=True)
+    def do_debug_delete_obj(self, args, repository):
+        """delete the objects with the given IDs from the repo"""
+        modified = False
+        for hex_id in args.ids:
+            try:
+                id = unhexlify(hex_id)
+            except ValueError:
+                print("object id %s is invalid." % hex_id)
+            else:
+                try:
+                    repository.delete(id)
+                    modified = True
+                    print("object %s deleted." % hex_id)
+                except Repository.ObjectNotFound:
+                    print("object %s not found." % hex_id)
+        if modified:
+            repository.commit(compact=False)
+        print("Done.")
+        return EXIT_SUCCESS
+
+    @with_repository(manifest=False, exclusive=True, cache=True, compatibility=Manifest.NO_OPERATION_CHECK)
+    def do_debug_refcount_obj(self, args, repository, manifest, key, cache):
+        """display refcounts for the objects with the given IDs"""
+        for hex_id in args.ids:
+            try:
+                id = unhexlify(hex_id)
+            except ValueError:
+                print("object id %s is invalid." % hex_id)
+            else:
+                try:
+                    refcount = cache.chunks[id][0]
+                    print("object %s has %d referrers [info from chunks cache]." % (hex_id, refcount))
+                except KeyError:
+                    print("object %s not found [info from chunks cache]." % hex_id)
+        return EXIT_SUCCESS
+
+    @with_repository(manifest=False, exclusive=True)
+    def do_debug_dump_hints(self, args, repository):
+        """dump repository hints"""
+        if not repository._active_txn:
+            repository.prepare_txn(repository.get_transaction_id())
+        try:
+            hints = dict(
+                segments=repository.segments,
+                compact=repository.compact,
+                storage_quota_use=repository.storage_quota_use,
+                shadow_index={hexlify(k).decode(): v for k, v in repository.shadow_index.items()},
+            )
+            with dash_open(args.path, "w") as fd:
+                json.dump(hints, fd, indent=4)
+        finally:
+            repository.rollback()
+        return EXIT_SUCCESS
+
+    def do_debug_convert_profile(self, args):
+        """convert Borg profile to Python profile"""
+        import marshal
+
+        with args.output, args.input:
+            marshal.dump(msgpack.unpack(args.input, use_list=False, raw=False), args.output)
+        return EXIT_SUCCESS
+
+    def build_parser_debug(self, subparsers, common_parser, mid_common_parser):
+
+        debug_epilog = process_epilog(
+            """
+        These commands are not intended for normal use and potentially very
+        dangerous if used incorrectly.
+
+        They exist to improve debugging capabilities without direct system access, e.g.
+        in case you ever run into some severe malfunction. Use them only if you know
+        what you are doing or if a trusted developer tells you what to do."""
+        )
+
+        subparser = subparsers.add_parser(
+            "debug",
+            parents=[mid_common_parser],
+            add_help=False,
+            description="debugging command (not intended for normal use)",
+            epilog=debug_epilog,
+            formatter_class=argparse.RawDescriptionHelpFormatter,
+            help="debugging command (not intended for normal use)",
+        )
+
+        debug_parsers = subparser.add_subparsers(title="required arguments", metavar="<command>")
+        subparser.set_defaults(fallback_func=functools.partial(self.do_subcommand_help, subparser))
+
+        debug_info_epilog = process_epilog(
+            """
+        This command displays some system information that might be useful for bug
+        reports and debugging problems. If a traceback happens, this information is
+        already appended at the end of the traceback.
+        """
+        )
+        subparser = debug_parsers.add_parser(
+            "info",
+            parents=[common_parser],
+            add_help=False,
+            description=self.do_debug_info.__doc__,
+            epilog=debug_info_epilog,
+            formatter_class=argparse.RawDescriptionHelpFormatter,
+            help="show system infos for debugging / bug reports (debug)",
+        )
+        subparser.set_defaults(func=self.do_debug_info)
+
+        debug_dump_archive_items_epilog = process_epilog(
+            """
+        This command dumps raw (but decrypted and decompressed) archive items (only metadata) to files.
+        """
+        )
+        subparser = debug_parsers.add_parser(
+            "dump-archive-items",
+            parents=[common_parser],
+            add_help=False,
+            description=self.do_debug_dump_archive_items.__doc__,
+            epilog=debug_dump_archive_items_epilog,
+            formatter_class=argparse.RawDescriptionHelpFormatter,
+            help="dump archive items (metadata) (debug)",
+        )
+        subparser.set_defaults(func=self.do_debug_dump_archive_items)
+        subparser.add_argument("name", metavar="NAME", type=NameSpec, help="specify the archive name")
+
+        debug_dump_archive_epilog = process_epilog(
+            """
+        This command dumps all metadata of an archive in a decoded form to a file.
+        """
+        )
+        subparser = debug_parsers.add_parser(
+            "dump-archive",
+            parents=[common_parser],
+            add_help=False,
+            description=self.do_debug_dump_archive.__doc__,
+            epilog=debug_dump_archive_epilog,
+            formatter_class=argparse.RawDescriptionHelpFormatter,
+            help="dump decoded archive metadata (debug)",
+        )
+        subparser.set_defaults(func=self.do_debug_dump_archive)
+        subparser.add_argument("name", metavar="NAME", type=NameSpec, help="specify the archive name")
+        subparser.add_argument("path", metavar="PATH", type=str, help="file to dump data into")
+
+        debug_dump_manifest_epilog = process_epilog(
+            """
+        This command dumps manifest metadata of a repository in a decoded form to a file.
+        """
+        )
+        subparser = debug_parsers.add_parser(
+            "dump-manifest",
+            parents=[common_parser],
+            add_help=False,
+            description=self.do_debug_dump_manifest.__doc__,
+            epilog=debug_dump_manifest_epilog,
+            formatter_class=argparse.RawDescriptionHelpFormatter,
+            help="dump decoded repository metadata (debug)",
+        )
+        subparser.set_defaults(func=self.do_debug_dump_manifest)
+        subparser.add_argument("path", metavar="PATH", type=str, help="file to dump data into")
+
+        debug_dump_repo_objs_epilog = process_epilog(
+            """
+        This command dumps raw (but decrypted and decompressed) repo objects to files.
+        """
+        )
+        subparser = debug_parsers.add_parser(
+            "dump-repo-objs",
+            parents=[common_parser],
+            add_help=False,
+            description=self.do_debug_dump_repo_objs.__doc__,
+            epilog=debug_dump_repo_objs_epilog,
+            formatter_class=argparse.RawDescriptionHelpFormatter,
+            help="dump repo objects (debug)",
+        )
+        subparser.set_defaults(func=self.do_debug_dump_repo_objs)
+        subparser.add_argument(
+            "--ghost",
+            dest="ghost",
+            action="store_true",
+            help="dump all segment file contents, including deleted/uncommitted objects and commits.",
+        )
+        subparser.add_argument(
+            "--segment",
+            metavar="SEG",
+            dest="segment",
+            default=None,
+            type=positive_int_validator,
+            help="used together with --ghost: limit processing to given segment.",
+        )
+        subparser.add_argument(
+            "--offset",
+            metavar="OFFS",
+            dest="offset",
+            default=None,
+            type=positive_int_validator,
+            help="used together with --ghost: limit processing to given offset.",
+        )
+
+        debug_search_repo_objs_epilog = process_epilog(
+            """
+        This command searches raw (but decrypted and decompressed) repo objects for a specific bytes sequence.
+        """
+        )
+        subparser = debug_parsers.add_parser(
+            "search-repo-objs",
+            parents=[common_parser],
+            add_help=False,
+            description=self.do_debug_search_repo_objs.__doc__,
+            epilog=debug_search_repo_objs_epilog,
+            formatter_class=argparse.RawDescriptionHelpFormatter,
+            help="search repo objects (debug)",
+        )
+        subparser.set_defaults(func=self.do_debug_search_repo_objs)
+        subparser.add_argument(
+            "wanted",
+            metavar="WANTED",
+            type=str,
+            help="term to search the repo for, either 0x1234abcd hex term or a string",
+        )
+
+        debug_get_obj_epilog = process_epilog(
+            """
+        This command gets an object from the repository.
+        """
+        )
+        subparser = debug_parsers.add_parser(
+            "get-obj",
+            parents=[common_parser],
+            add_help=False,
+            description=self.do_debug_get_obj.__doc__,
+            epilog=debug_get_obj_epilog,
+            formatter_class=argparse.RawDescriptionHelpFormatter,
+            help="get object from repository (debug)",
+        )
+        subparser.set_defaults(func=self.do_debug_get_obj)
+        subparser.add_argument("id", metavar="ID", type=str, help="hex object ID to get from the repo")
+        subparser.add_argument("path", metavar="PATH", type=str, help="file to write object data into")
+
+        debug_put_obj_epilog = process_epilog(
+            """
+        This command puts objects into the repository.
+        """
+        )
+        subparser = debug_parsers.add_parser(
+            "put-obj",
+            parents=[common_parser],
+            add_help=False,
+            description=self.do_debug_put_obj.__doc__,
+            epilog=debug_put_obj_epilog,
+            formatter_class=argparse.RawDescriptionHelpFormatter,
+            help="put object to repository (debug)",
+        )
+        subparser.set_defaults(func=self.do_debug_put_obj)
+        subparser.add_argument(
+            "paths", metavar="PATH", nargs="+", type=str, help="file(s) to read and create object(s) from"
+        )
+
+        debug_delete_obj_epilog = process_epilog(
+            """
+        This command deletes objects from the repository.
+        """
+        )
+        subparser = debug_parsers.add_parser(
+            "delete-obj",
+            parents=[common_parser],
+            add_help=False,
+            description=self.do_debug_delete_obj.__doc__,
+            epilog=debug_delete_obj_epilog,
+            formatter_class=argparse.RawDescriptionHelpFormatter,
+            help="delete object from repository (debug)",
+        )
+        subparser.set_defaults(func=self.do_debug_delete_obj)
+        subparser.add_argument(
+            "ids", metavar="IDs", nargs="+", type=str, help="hex object ID(s) to delete from the repo"
+        )
+
+        debug_refcount_obj_epilog = process_epilog(
+            """
+        This command displays the reference count for objects from the repository.
+        """
+        )
+        subparser = debug_parsers.add_parser(
+            "refcount-obj",
+            parents=[common_parser],
+            add_help=False,
+            description=self.do_debug_refcount_obj.__doc__,
+            epilog=debug_refcount_obj_epilog,
+            formatter_class=argparse.RawDescriptionHelpFormatter,
+            help="show refcount for object from repository (debug)",
+        )
+        subparser.set_defaults(func=self.do_debug_refcount_obj)
+        subparser.add_argument("ids", metavar="IDs", nargs="+", type=str, help="hex object ID(s) to show refcounts for")
+
+        debug_dump_hints_epilog = process_epilog(
+            """
+        This command dumps the repository hints data.
+        """
+        )
+        subparser = debug_parsers.add_parser(
+            "dump-hints",
+            parents=[common_parser],
+            add_help=False,
+            description=self.do_debug_dump_hints.__doc__,
+            epilog=debug_dump_hints_epilog,
+            formatter_class=argparse.RawDescriptionHelpFormatter,
+            help="dump repo hints (debug)",
+        )
+        subparser.set_defaults(func=self.do_debug_dump_hints)
+        subparser.add_argument("path", metavar="PATH", type=str, help="file to dump data into")
+
+        debug_convert_profile_epilog = process_epilog(
+            """
+        Convert a Borg profile to a Python cProfile compatible profile.
+        """
+        )
+        subparser = debug_parsers.add_parser(
+            "convert-profile",
+            parents=[common_parser],
+            add_help=False,
+            description=self.do_debug_convert_profile.__doc__,
+            epilog=debug_convert_profile_epilog,
+            formatter_class=argparse.RawDescriptionHelpFormatter,
+            help="convert Borg profile to Python profile (debug)",
+        )
+        subparser.set_defaults(func=self.do_debug_convert_profile)
+        subparser.add_argument("input", metavar="INPUT", type=argparse.FileType("rb"), help="Borg profile")
+        subparser.add_argument("output", metavar="OUTPUT", type=argparse.FileType("wb"), help="Output file")
diff --git a/src/borg/remote.py b/src/borg/remote.py
index a1196d600..f3b7ef6f0 100644
--- a/src/borg/remote.py
+++ b/src/borg/remote.py
@@ -727,7 +727,7 @@ This problem will go away as soon as the server has been upgraded to 1.0.7+.
                 opts.append("--storage-quota=%s" % args.storage_quota)
         env_vars = []
         if testing:
-            return env_vars + [sys.executable, "-m", "borg.archiver", "serve"] + opts + self.extra_test_args
+            return env_vars + [sys.executable, "-m", "borg", "serve"] + opts + self.extra_test_args
         else:  # pragma: no cover
             remote_path = args.remote_path or os.environ.get("BORG_REMOTE_PATH", "borg")
             remote_path = replace_placeholders(remote_path)
diff --git a/src/borg/testsuite/archiver.py b/src/borg/testsuite/archiver.py
index 63bb8beca..5b371bab1 100644
--- a/src/borg/testsuite/archiver.py
+++ b/src/borg/testsuite/archiver.py
@@ -73,7 +73,7 @@ def exec_cmd(*args, archiver=None, fork=False, exe=None, input=b"", binary_outpu
     if fork:
         try:
             if exe is None:
-                borg = (sys.executable, "-m", "borg.archiver")
+                borg = (sys.executable, "-m", "borg")
             elif isinstance(exe, str):
                 borg = (exe,)
             elif not isinstance(exe, tuple):
@@ -3524,7 +3524,6 @@ id: 2 / e29442 3506da 4e1ea7 / 25f62a 5a3d41 - 02
 
     def test_debug_info(self):
         output = self.cmd("debug", "info")
-        assert "CRC implementation" in output
         assert "Python" in output
 
     def test_benchmark_crud(self):
diff --git a/src/borg/testsuite/repository.py b/src/borg/testsuite/repository.py
index 9c2ffefe4..02d93e918 100644
--- a/src/borg/testsuite/repository.py
+++ b/src/borg/testsuite/repository.py
@@ -955,7 +955,7 @@ class RemoteRepositoryTestCase(RepositoryTestCase):
         assert self.repository.ssh_cmd(Location("ssh://example.com/foo")) == ["ssh", "--foo", "example.com"]
 
     def test_borg_cmd(self):
-        assert self.repository.borg_cmd(None, testing=True) == [sys.executable, "-m", "borg.archiver", "serve"]
+        assert self.repository.borg_cmd(None, testing=True) == [sys.executable, "-m", "borg", "serve"]
         args = self._get_mock_args()
         # XXX without next line we get spurious test fails when using pytest-xdist, root cause unknown:
         logging.getLogger().setLevel(logging.INFO)

From 27b63e7c48d9dc5565bb9d9c57d119d15fc5c6e9 Mon Sep 17 00:00:00 2001
From: Thomas Waldmann <tw@waldmann-edv.de>
Date: Fri, 8 Jul 2022 02:22:00 +0200
Subject: [PATCH 119/160] move tar commands to archiver.tar

---
 setup.cfg                     |   1 +
 src/borg/archiver/__init__.py | 572 +---------------------------------
 src/borg/archiver/common.py   |  74 ++++-
 src/borg/archiver/tar.py      | 520 +++++++++++++++++++++++++++++++
 4 files changed, 600 insertions(+), 567 deletions(-)
 create mode 100644 src/borg/archiver/tar.py

diff --git a/setup.cfg b/setup.cfg
index 64e6a29b8..bf668fc4e 100644
--- a/setup.cfg
+++ b/setup.cfg
@@ -119,6 +119,7 @@ per_file_ignores =
     src/borg/archiver/__init__.py:E402,E501,E722,E741,F405
     src/borg/archiver/common.py:E501,F405
     src/borg/archiver/debug.py:F405
+    src/borg/archiver/tar.py:F405
     src/borg/cache.py:E127,E128,E402,E501,E722,W504
     src/borg/fuse.py:E402,E501,E722,W504
     src/borg/fuse_impl.py:F811
diff --git a/src/borg/archiver/__init__.py b/src/borg/archiver/__init__.py
index cd0f2ba49..8eabb5f4e 100644
--- a/src/borg/archiver/__init__.py
+++ b/src/borg/archiver/__init__.py
@@ -5,7 +5,6 @@ import traceback
 
 try:
     import argparse
-    import base64
     import collections
     import configparser
     import faulthandler
@@ -21,7 +20,6 @@ try:
     import signal
     import stat
     import subprocess
-    import tarfile
     import textwrap
     import time
     from binascii import unhexlify
@@ -38,7 +36,7 @@ try:
     from .. import helpers
     from ..archive import Archive, ArchiveChecker, ArchiveRecreater, Statistics, is_special
     from ..archive import BackupError, BackupOSError, backup_io, OsOpen, stat_update_check
-    from ..archive import FilesystemObjectProcessors, TarfileObjectProcessors, MetadataCollector, ChunksProcessor
+    from ..archive import FilesystemObjectProcessors, MetadataCollector, ChunksProcessor
     from ..cache import Cache, assert_secure, SecurityManager
     from ..constants import *  # NOQA
     from ..compress import CompressionSpec
@@ -65,22 +63,13 @@ try:
     from ..helpers import ErrorIgnoringTextIOWrapper
     from ..helpers import ProgressIndicatorPercent
     from ..helpers import basic_json_data, json_print
-    from ..helpers import ChunkIteratorFileWrapper
-    from ..helpers import prepare_subprocess_env, create_filter_process
-    from ..helpers import dash_open
+    from ..helpers import prepare_subprocess_env
     from ..helpers import umount
     from ..helpers import flags_root, flags_dir, flags_special_follow, flags_special
     from ..helpers import msgpack
     from ..helpers import sig_int
     from ..helpers import iter_separated
-    from ..helpers import get_tar_filter
     from ..nanorst import rst_to_terminal
-    from ..patterns import (
-        ArgparsePatternAction,
-        ArgparseExcludeFileAction,
-        ArgparsePatternFileAction,
-        parse_exclude_pattern,
-    )
     from ..patterns import PatternMatcher
     from ..item import Item
     from ..platform import get_flags, SyncFile
@@ -122,9 +111,10 @@ def get_func(args):
 
 
 from .debug import DebugMixIn
+from .tar import TarMixIn
 
 
-class Archiver(DebugMixIn):
+class Archiver(DebugMixIn, TarMixIn):
     def __init__(self, lock_wait=None, prog=None):
         self.exit_code = EXIT_SUCCESS
         self.lock_wait = lock_wait
@@ -1196,194 +1186,6 @@ class Archiver(DebugMixIn):
             pi.finish()
         return self.exit_code
 
-    @with_repository(compatibility=(Manifest.Operation.READ,))
-    @with_archive
-    def do_export_tar(self, args, repository, manifest, key, archive):
-        """Export archive contents as a tarball"""
-        self.output_list = args.output_list
-
-        # A quick note about the general design of tar_filter and tarfile;
-        # The tarfile module of Python can provide some compression mechanisms
-        # by itself, using the builtin gzip, bz2 and lzma modules (and "tarmodes"
-        # such as "w:xz").
-        #
-        # Doing so would have three major drawbacks:
-        # For one the compressor runs on the same thread as the program using the
-        # tarfile, stealing valuable CPU time from Borg and thus reducing throughput.
-        # Then this limits the available options - what about lz4? Brotli? zstd?
-        # The third issue is that systems can ship more optimized versions than those
-        # built into Python, e.g. pigz or pxz, which can use more than one thread for
-        # compression.
-        #
-        # Therefore we externalize compression by using a filter program, which has
-        # none of these drawbacks. The only issue of using an external filter is
-        # that it has to be installed -- hardly a problem, considering that
-        # the decompressor must be installed as well to make use of the exported tarball!
-
-        filter = get_tar_filter(args.tarfile, decompress=False) if args.tar_filter == "auto" else args.tar_filter
-
-        tarstream = dash_open(args.tarfile, "wb")
-        tarstream_close = args.tarfile != "-"
-
-        with create_filter_process(filter, stream=tarstream, stream_close=tarstream_close, inbound=False) as _stream:
-            self._export_tar(args, archive, _stream)
-
-        return self.exit_code
-
-    def _export_tar(self, args, archive, tarstream):
-        matcher = self.build_matcher(args.patterns, args.paths)
-
-        progress = args.progress
-        output_list = args.output_list
-        strip_components = args.strip_components
-        hlm = HardLinkManager(id_type=bytes, info_type=str)  # hlid -> path
-
-        filter = self.build_filter(matcher, strip_components)
-
-        # The | (pipe) symbol instructs tarfile to use a streaming mode of operation
-        # where it never seeks on the passed fileobj.
-        tar_format = dict(GNU=tarfile.GNU_FORMAT, PAX=tarfile.PAX_FORMAT, BORG=tarfile.PAX_FORMAT)[args.tar_format]
-        tar = tarfile.open(fileobj=tarstream, mode="w|", format=tar_format)
-
-        if progress:
-            pi = ProgressIndicatorPercent(msg="%5.1f%% Processing: %s", step=0.1, msgid="extract")
-            pi.output("Calculating size")
-            extracted_size = sum(item.get_size() for item in archive.iter_items(filter))
-            pi.total = extracted_size
-        else:
-            pi = None
-
-        def item_content_stream(item):
-            """
-            Return a file-like object that reads from the chunks of *item*.
-            """
-            chunk_iterator = archive.pipeline.fetch_many([chunk_id for chunk_id, _ in item.chunks], is_preloaded=True)
-            if pi:
-                info = [remove_surrogates(item.path)]
-                return ChunkIteratorFileWrapper(
-                    chunk_iterator, lambda read_bytes: pi.show(increase=len(read_bytes), info=info)
-                )
-            else:
-                return ChunkIteratorFileWrapper(chunk_iterator)
-
-        def item_to_tarinfo(item, original_path):
-            """
-            Transform a Borg *item* into a tarfile.TarInfo object.
-
-            Return a tuple (tarinfo, stream), where stream may be a file-like object that represents
-            the file contents, if any, and is None otherwise. When *tarinfo* is None, the *item*
-            cannot be represented as a TarInfo object and should be skipped.
-            """
-            stream = None
-            tarinfo = tarfile.TarInfo()
-            tarinfo.name = item.path
-            tarinfo.mtime = item.mtime / 1e9
-            tarinfo.mode = stat.S_IMODE(item.mode)
-            tarinfo.uid = item.uid
-            tarinfo.gid = item.gid
-            tarinfo.uname = item.get("user", "")
-            tarinfo.gname = item.get("group", "")
-            # The linkname in tar has 2 uses:
-            # for symlinks it means the destination, while for hardlinks it refers to the file.
-            # Since hardlinks in tar have a different type code (LNKTYPE) the format might
-            # support hardlinking arbitrary objects (including symlinks and directories), but
-            # whether implementations actually support that is a whole different question...
-            tarinfo.linkname = ""
-
-            modebits = stat.S_IFMT(item.mode)
-            if modebits == stat.S_IFREG:
-                tarinfo.type = tarfile.REGTYPE
-                if "hlid" in item:
-                    linkname = hlm.retrieve(id=item.hlid)
-                    if linkname is not None:
-                        # the first hardlink was already added to the archive, add a tar-hardlink reference to it.
-                        tarinfo.type = tarfile.LNKTYPE
-                        tarinfo.linkname = linkname
-                    else:
-                        tarinfo.size = item.get_size()
-                        stream = item_content_stream(item)
-                        hlm.remember(id=item.hlid, info=item.path)
-                else:
-                    tarinfo.size = item.get_size()
-                    stream = item_content_stream(item)
-            elif modebits == stat.S_IFDIR:
-                tarinfo.type = tarfile.DIRTYPE
-            elif modebits == stat.S_IFLNK:
-                tarinfo.type = tarfile.SYMTYPE
-                tarinfo.linkname = item.source
-            elif modebits == stat.S_IFBLK:
-                tarinfo.type = tarfile.BLKTYPE
-                tarinfo.devmajor = os.major(item.rdev)
-                tarinfo.devminor = os.minor(item.rdev)
-            elif modebits == stat.S_IFCHR:
-                tarinfo.type = tarfile.CHRTYPE
-                tarinfo.devmajor = os.major(item.rdev)
-                tarinfo.devminor = os.minor(item.rdev)
-            elif modebits == stat.S_IFIFO:
-                tarinfo.type = tarfile.FIFOTYPE
-            else:
-                self.print_warning(
-                    "%s: unsupported file type %o for tar export", remove_surrogates(item.path), modebits
-                )
-                set_ec(EXIT_WARNING)
-                return None, stream
-            return tarinfo, stream
-
-        def item_to_paxheaders(format, item):
-            """
-            Transform (parts of) a Borg *item* into a pax_headers dict.
-            """
-            # PAX format
-            # ----------
-            # When using the PAX (POSIX) format, we can support some things that aren't possible
-            # with classic tar formats, including GNU tar, such as:
-            # - atime, ctime (DONE)
-            # - possibly Linux capabilities, security.* xattrs (TODO)
-            # - various additions supported by GNU tar in POSIX mode (TODO)
-            #
-            # BORG format
-            # -----------
-            # This is based on PAX, but additionally adds BORG.* pax headers.
-            # Additionally to the standard tar / PAX metadata and data, it transfers
-            # ALL borg item metadata in a BORG specific way.
-            #
-            ph = {}
-            # note: for mtime this is a bit redundant as it is already done by tarfile module,
-            #       but we just do it in our way to be consistent for sure.
-            for name in "atime", "ctime", "mtime":
-                if hasattr(item, name):
-                    ns = getattr(item, name)
-                    ph[name] = str(ns / 1e9)
-            if format == "BORG":  # BORG format additions
-                ph["BORG.item.version"] = "1"
-                # BORG.item.meta - just serialize all metadata we have:
-                meta_bin = msgpack.packb(item.as_dict())
-                meta_text = base64.b64encode(meta_bin).decode()
-                ph["BORG.item.meta"] = meta_text
-            return ph
-
-        for item in archive.iter_items(filter, preload=True):
-            orig_path = item.path
-            if strip_components:
-                item.path = os.sep.join(orig_path.split(os.sep)[strip_components:])
-            tarinfo, stream = item_to_tarinfo(item, orig_path)
-            if tarinfo:
-                if args.tar_format in ("BORG", "PAX"):
-                    tarinfo.pax_headers = item_to_paxheaders(args.tar_format, item)
-                if output_list:
-                    logging.getLogger("borg.output.list").info(remove_surrogates(orig_path))
-                tar.addfile(tarinfo, stream)
-
-        if pi:
-            pi.finish()
-
-        # This does not close the fileobj (tarstream) we passed to it -- a side effect of the | mode.
-        tar.close()
-
-        for pattern in matcher.get_unmatched_include_patterns():
-            self.print_warning("Include pattern '%s' never matched.", pattern)
-        return self.exit_code
-
     @with_repository(compatibility=(Manifest.Operation.READ,))
     @with_archive
     def do_diff(self, args, repository, manifest, key, archive):
@@ -1908,102 +1710,6 @@ class Archiver(DebugMixIn):
             cache.commit()
         return self.exit_code
 
-    @with_repository(cache=True, exclusive=True, compatibility=(Manifest.Operation.WRITE,))
-    def do_import_tar(self, args, repository, manifest, key, cache):
-        """Create a backup archive from a tarball"""
-        self.output_filter = args.output_filter
-        self.output_list = args.output_list
-
-        filter = get_tar_filter(args.tarfile, decompress=True) if args.tar_filter == "auto" else args.tar_filter
-
-        tarstream = dash_open(args.tarfile, "rb")
-        tarstream_close = args.tarfile != "-"
-
-        with create_filter_process(filter, stream=tarstream, stream_close=tarstream_close, inbound=True) as _stream:
-            self._import_tar(args, repository, manifest, key, cache, _stream)
-
-        return self.exit_code
-
-    def _import_tar(self, args, repository, manifest, key, cache, tarstream):
-        t0 = datetime.utcnow()
-        t0_monotonic = time.monotonic()
-
-        archive = Archive(
-            repository,
-            key,
-            manifest,
-            args.name,
-            cache=cache,
-            create=True,
-            checkpoint_interval=args.checkpoint_interval,
-            progress=args.progress,
-            chunker_params=args.chunker_params,
-            start=t0,
-            start_monotonic=t0_monotonic,
-            log_json=args.log_json,
-        )
-        cp = ChunksProcessor(
-            cache=cache,
-            key=key,
-            add_item=archive.add_item,
-            write_checkpoint=archive.write_checkpoint,
-            checkpoint_interval=args.checkpoint_interval,
-            rechunkify=False,
-        )
-        tfo = TarfileObjectProcessors(
-            cache=cache,
-            key=key,
-            process_file_chunks=cp.process_file_chunks,
-            add_item=archive.add_item,
-            chunker_params=args.chunker_params,
-            show_progress=args.progress,
-            log_json=args.log_json,
-            iec=args.iec,
-            file_status_printer=self.print_file_status,
-        )
-
-        tar = tarfile.open(fileobj=tarstream, mode="r|")
-
-        while True:
-            tarinfo = tar.next()
-            if not tarinfo:
-                break
-            if tarinfo.isreg():
-                status = tfo.process_file(tarinfo=tarinfo, status="A", type=stat.S_IFREG, tar=tar)
-                archive.stats.nfiles += 1
-            elif tarinfo.isdir():
-                status = tfo.process_dir(tarinfo=tarinfo, status="d", type=stat.S_IFDIR)
-            elif tarinfo.issym():
-                status = tfo.process_symlink(tarinfo=tarinfo, status="s", type=stat.S_IFLNK)
-            elif tarinfo.islnk():
-                # tar uses a hardlink model like: the first instance of a hardlink is stored as a regular file,
-                # later instances are special entries referencing back to the first instance.
-                status = tfo.process_hardlink(tarinfo=tarinfo, status="h", type=stat.S_IFREG)
-            elif tarinfo.isblk():
-                status = tfo.process_dev(tarinfo=tarinfo, status="b", type=stat.S_IFBLK)
-            elif tarinfo.ischr():
-                status = tfo.process_dev(tarinfo=tarinfo, status="c", type=stat.S_IFCHR)
-            elif tarinfo.isfifo():
-                status = tfo.process_fifo(tarinfo=tarinfo, status="f", type=stat.S_IFIFO)
-            else:
-                status = "E"
-                self.print_warning("%s: Unsupported tarinfo type %s", tarinfo.name, tarinfo.type)
-            self.print_file_status(status, tarinfo.name)
-
-        # This does not close the fileobj (tarstream) we passed to it -- a side effect of the | mode.
-        tar.close()
-
-        if args.progress:
-            archive.stats.show_progress(final=True)
-        archive.stats += tfo.stats
-        archive.save(comment=args.comment, timestamp=args.timestamp)
-        args.stats |= args.json
-        if args.stats:
-            if args.json:
-                json_print(basic_json_data(archive.manifest, cache=archive.cache, extra={"archive": archive}))
-            else:
-                log_multi(str(archive), str(archive.stats), logger=logging.getLogger("borg.output.stats"))
-
     @with_repository(manifest=False, exclusive=True)
     def do_with_lock(self, args, repository):
         """run a user specified command with the repository lock held"""
@@ -2740,6 +2446,7 @@ class Archiver(DebugMixIn):
     def build_parser(self):
 
         from .common import process_epilog
+        from .common import define_exclusion_group
 
         def define_common_options(add_common_option):
             add_common_option("-h", "--help", action="help", help="show this help message and exit")
@@ -2881,75 +2588,6 @@ class Archiver(DebugMixIn):
                 help="repository to use",
             )
 
-        def define_exclude_and_patterns(add_option, *, tag_files=False, strip_components=False):
-            add_option(
-                "-e",
-                "--exclude",
-                metavar="PATTERN",
-                dest="patterns",
-                type=parse_exclude_pattern,
-                action="append",
-                help="exclude paths matching PATTERN",
-            )
-            add_option(
-                "--exclude-from",
-                metavar="EXCLUDEFILE",
-                action=ArgparseExcludeFileAction,
-                help="read exclude patterns from EXCLUDEFILE, one per line",
-            )
-            add_option(
-                "--pattern",
-                metavar="PATTERN",
-                action=ArgparsePatternAction,
-                help="include/exclude paths matching PATTERN",
-            )
-            add_option(
-                "--patterns-from",
-                metavar="PATTERNFILE",
-                action=ArgparsePatternFileAction,
-                help="read include/exclude patterns from PATTERNFILE, one per line",
-            )
-
-            if tag_files:
-                add_option(
-                    "--exclude-caches",
-                    dest="exclude_caches",
-                    action="store_true",
-                    help="exclude directories that contain a CACHEDIR.TAG file "
-                    "(http://www.bford.info/cachedir/spec.html)",
-                )
-                add_option(
-                    "--exclude-if-present",
-                    metavar="NAME",
-                    dest="exclude_if_present",
-                    action="append",
-                    type=str,
-                    help="exclude directories that are tagged by containing a filesystem object with " "the given NAME",
-                )
-                add_option(
-                    "--keep-exclude-tags",
-                    dest="keep_exclude_tags",
-                    action="store_true",
-                    help="if tag objects are specified with ``--exclude-if-present``, "
-                    "don't omit the tag objects themselves from the backup archive",
-                )
-
-            if strip_components:
-                add_option(
-                    "--strip-components",
-                    metavar="NUMBER",
-                    dest="strip_components",
-                    type=int,
-                    default=0,
-                    help="Remove the specified number of leading path elements. "
-                    "Paths with fewer elements will be silently skipped.",
-                )
-
-        def define_exclusion_group(subparser, **kwargs):
-            exclude_group = subparser.add_argument_group("Exclusion options")
-            define_exclude_and_patterns(exclude_group.add_argument, **kwargs)
-            return exclude_group
-
         def define_archive_filters_group(subparser, *, sort_by=True, first_last=True):
             filters_group = subparser.add_argument_group(
                 "Archive filters", "Archive filters can be applied to repository targets."
@@ -4044,83 +3682,6 @@ class Archiver(DebugMixIn):
         )
         define_exclusion_group(subparser)
 
-        # borg export-tar
-        export_tar_epilog = process_epilog(
-            """
-        This command creates a tarball from an archive.
-
-        When giving '-' as the output FILE, Borg will write a tar stream to standard output.
-
-        By default (``--tar-filter=auto``) Borg will detect whether the FILE should be compressed
-        based on its file extension and pipe the tarball through an appropriate filter
-        before writing it to FILE:
-
-        - .tar.gz or .tgz: gzip
-        - .tar.bz2 or .tbz: bzip2
-        - .tar.xz or .txz: xz
-        - .tar.zstd: zstd
-        - .tar.lz4: lz4
-
-        Alternatively, a ``--tar-filter`` program may be explicitly specified. It should
-        read the uncompressed tar stream from stdin and write a compressed/filtered
-        tar stream to stdout.
-
-        Depending on the ``-tar-format`` option, these formats are created:
-
-        +--------------+---------------------------+----------------------------+
-        | --tar-format | Specification             | Metadata                   |
-        +--------------+---------------------------+----------------------------+
-        | BORG         | BORG specific, like PAX   | all as supported by borg   |
-        +--------------+---------------------------+----------------------------+
-        | PAX          | POSIX.1-2001 (pax) format | GNU + atime/ctime/mtime ns |
-        +--------------+---------------------------+----------------------------+
-        | GNU          | GNU tar format            | mtime s, no atime/ctime,   |
-        |              |                           | no ACLs/xattrs/bsdflags    |
-        +--------------+---------------------------+----------------------------+
-
-        A ``--sparse`` option (as found in borg extract) is not supported.
-
-        By default the entire archive is extracted but a subset of files and directories
-        can be selected by passing a list of ``PATHs`` as arguments.
-        The file selection can further be restricted by using the ``--exclude`` option.
-
-        For more help on include/exclude patterns, see the :ref:`borg_patterns` command output.
-
-        ``--progress`` can be slower than no progress display, since it makes one additional
-        pass over the archive metadata.
-        """
-        )
-        subparser = subparsers.add_parser(
-            "export-tar",
-            parents=[common_parser],
-            add_help=False,
-            description=self.do_export_tar.__doc__,
-            epilog=export_tar_epilog,
-            formatter_class=argparse.RawDescriptionHelpFormatter,
-            help="create tarball from archive",
-        )
-        subparser.set_defaults(func=self.do_export_tar)
-        subparser.add_argument(
-            "--tar-filter", dest="tar_filter", default="auto", help="filter program to pipe data through"
-        )
-        subparser.add_argument(
-            "--list", dest="output_list", action="store_true", help="output verbose list of items (files, dirs, ...)"
-        )
-        subparser.add_argument(
-            "--tar-format",
-            metavar="FMT",
-            dest="tar_format",
-            default="GNU",
-            choices=("BORG", "PAX", "GNU"),
-            help="select tar format: BORG, PAX or GNU",
-        )
-        subparser.add_argument("name", metavar="NAME", type=NameSpec, help="specify the archive name")
-        subparser.add_argument("tarfile", metavar="FILE", help='output tar file. "-" to write to stdout instead.')
-        subparser.add_argument(
-            "paths", metavar="PATH", nargs="*", type=str, help="paths to extract; patterns are supported"
-        )
-        define_exclusion_group(subparser, strip_components=True)
-
         # borg extract
         extract_epilog = process_epilog(
             """
@@ -5167,129 +4728,8 @@ class Archiver(DebugMixIn):
         subparser.add_argument("command", metavar="COMMAND", help="command to run")
         subparser.add_argument("args", metavar="ARGS", nargs=argparse.REMAINDER, help="command arguments")
 
-        # borg import-tar
-        import_tar_epilog = process_epilog(
-            """
-        This command creates a backup archive from a tarball.
+        self.build_parser_tar(subparsers, common_parser, mid_common_parser)
 
-        When giving '-' as path, Borg will read a tar stream from standard input.
-
-        By default (--tar-filter=auto) Borg will detect whether the file is compressed
-        based on its file extension and pipe the file through an appropriate filter:
-
-        - .tar.gz or .tgz: gzip -d
-        - .tar.bz2 or .tbz: bzip2 -d
-        - .tar.xz or .txz: xz -d
-        - .tar.zstd: zstd -d
-        - .tar.lz4: lz4 -d
-
-        Alternatively, a --tar-filter program may be explicitly specified. It should
-        read compressed data from stdin and output an uncompressed tar stream on
-        stdout.
-
-        Most documentation of borg create applies. Note that this command does not
-        support excluding files.
-
-        A ``--sparse`` option (as found in borg create) is not supported.
-
-        About tar formats and metadata conservation or loss, please see ``borg export-tar``.
-
-        import-tar reads these tar formats:
-
-        - BORG: borg specific (PAX-based)
-        - PAX: POSIX.1-2001
-        - GNU: GNU tar
-        - POSIX.1-1988 (ustar)
-        - UNIX V7 tar
-        - SunOS tar with extended attributes
-
-        """
-        )
-        subparser = subparsers.add_parser(
-            "import-tar",
-            parents=[common_parser],
-            add_help=False,
-            description=self.do_import_tar.__doc__,
-            epilog=import_tar_epilog,
-            formatter_class=argparse.RawDescriptionHelpFormatter,
-            help=self.do_import_tar.__doc__,
-        )
-        subparser.set_defaults(func=self.do_import_tar)
-        subparser.add_argument(
-            "--tar-filter",
-            dest="tar_filter",
-            default="auto",
-            action=Highlander,
-            help="filter program to pipe data through",
-        )
-        subparser.add_argument(
-            "-s",
-            "--stats",
-            dest="stats",
-            action="store_true",
-            default=False,
-            help="print statistics for the created archive",
-        )
-        subparser.add_argument(
-            "--list",
-            dest="output_list",
-            action="store_true",
-            default=False,
-            help="output verbose list of items (files, dirs, ...)",
-        )
-        subparser.add_argument(
-            "--filter",
-            dest="output_filter",
-            metavar="STATUSCHARS",
-            action=Highlander,
-            help="only display items with the given status characters",
-        )
-        subparser.add_argument("--json", action="store_true", help="output stats as JSON (implies --stats)")
-
-        archive_group = subparser.add_argument_group("Archive options")
-        archive_group.add_argument(
-            "--comment", dest="comment", metavar="COMMENT", default="", help="add a comment text to the archive"
-        )
-        archive_group.add_argument(
-            "--timestamp",
-            dest="timestamp",
-            type=timestamp,
-            default=None,
-            metavar="TIMESTAMP",
-            help="manually specify the archive creation date/time (UTC, yyyy-mm-ddThh:mm:ss format). "
-            "alternatively, give a reference file/directory.",
-        )
-        archive_group.add_argument(
-            "-c",
-            "--checkpoint-interval",
-            dest="checkpoint_interval",
-            type=int,
-            default=1800,
-            metavar="SECONDS",
-            help="write checkpoint every SECONDS seconds (Default: 1800)",
-        )
-        archive_group.add_argument(
-            "--chunker-params",
-            dest="chunker_params",
-            action=Highlander,
-            type=ChunkerParams,
-            default=CHUNKER_PARAMS,
-            metavar="PARAMS",
-            help="specify the chunker parameters (ALGO, CHUNK_MIN_EXP, CHUNK_MAX_EXP, "
-            "HASH_MASK_BITS, HASH_WINDOW_SIZE). default: %s,%d,%d,%d,%d" % CHUNKER_PARAMS,
-        )
-        archive_group.add_argument(
-            "-C",
-            "--compression",
-            metavar="COMPRESSION",
-            dest="compression",
-            type=CompressionSpec,
-            default=CompressionSpec("lz4"),
-            help="select compression algorithm, see the output of the " '"borg help compression" command for details.',
-        )
-
-        subparser.add_argument("name", metavar="NAME", type=NameSpec, help="specify the archive name")
-        subparser.add_argument("tarfile", metavar="TARFILE", help='input tar file. "-" to read from stdin instead.')
         return parser
 
     def get_args(self, argv, cmd):
diff --git a/src/borg/archiver/common.py b/src/borg/archiver/common.py
index 49d1c8a9f..d0c07bf00 100644
--- a/src/borg/archiver/common.py
+++ b/src/borg/archiver/common.py
@@ -10,8 +10,13 @@ from ..helpers import Error
 from ..helpers import Manifest
 from ..remote import RemoteRepository
 from ..repository import Repository
-
 from ..nanorst import rst_to_terminal
+from ..patterns import (
+    ArgparsePatternAction,
+    ArgparseExcludeFileAction,
+    ArgparsePatternFileAction,
+    parse_exclude_pattern,
+)
 
 from ..logger import create_logger
 
@@ -296,3 +301,70 @@ def process_epilog(epilog):
     if mode == "command-line":
         epilog = rst_to_terminal(epilog, rst_plain_text_references)
     return epilog
+
+
+def define_exclude_and_patterns(add_option, *, tag_files=False, strip_components=False):
+    add_option(
+        "-e",
+        "--exclude",
+        metavar="PATTERN",
+        dest="patterns",
+        type=parse_exclude_pattern,
+        action="append",
+        help="exclude paths matching PATTERN",
+    )
+    add_option(
+        "--exclude-from",
+        metavar="EXCLUDEFILE",
+        action=ArgparseExcludeFileAction,
+        help="read exclude patterns from EXCLUDEFILE, one per line",
+    )
+    add_option(
+        "--pattern", metavar="PATTERN", action=ArgparsePatternAction, help="include/exclude paths matching PATTERN"
+    )
+    add_option(
+        "--patterns-from",
+        metavar="PATTERNFILE",
+        action=ArgparsePatternFileAction,
+        help="read include/exclude patterns from PATTERNFILE, one per line",
+    )
+
+    if tag_files:
+        add_option(
+            "--exclude-caches",
+            dest="exclude_caches",
+            action="store_true",
+            help="exclude directories that contain a CACHEDIR.TAG file " "(http://www.bford.info/cachedir/spec.html)",
+        )
+        add_option(
+            "--exclude-if-present",
+            metavar="NAME",
+            dest="exclude_if_present",
+            action="append",
+            type=str,
+            help="exclude directories that are tagged by containing a filesystem object with " "the given NAME",
+        )
+        add_option(
+            "--keep-exclude-tags",
+            dest="keep_exclude_tags",
+            action="store_true",
+            help="if tag objects are specified with ``--exclude-if-present``, "
+            "don't omit the tag objects themselves from the backup archive",
+        )
+
+    if strip_components:
+        add_option(
+            "--strip-components",
+            metavar="NUMBER",
+            dest="strip_components",
+            type=int,
+            default=0,
+            help="Remove the specified number of leading path elements. "
+            "Paths with fewer elements will be silently skipped.",
+        )
+
+
+def define_exclusion_group(subparser, **kwargs):
+    exclude_group = subparser.add_argument_group("Exclusion options")
+    define_exclude_and_patterns(exclude_group.add_argument, **kwargs)
+    return exclude_group
diff --git a/src/borg/archiver/tar.py b/src/borg/archiver/tar.py
new file mode 100644
index 000000000..eb71cb2d8
--- /dev/null
+++ b/src/borg/archiver/tar.py
@@ -0,0 +1,520 @@
+import argparse
+import base64
+from datetime import datetime
+import logging
+import os
+import stat
+import tarfile
+import time
+
+from ..archive import Archive, TarfileObjectProcessors, ChunksProcessor
+from ..compress import CompressionSpec
+from ..constants import *  # NOQA
+from ..helpers import Manifest
+from ..helpers import HardLinkManager
+from ..helpers import ProgressIndicatorPercent
+from ..helpers import get_tar_filter
+from ..helpers import dash_open
+from ..helpers import msgpack
+from ..helpers import create_filter_process
+from ..helpers import ChunkIteratorFileWrapper
+from ..helpers import ChunkerParams
+from ..helpers import NameSpec
+from ..helpers import remove_surrogates
+from ..helpers import timestamp
+from ..helpers import basic_json_data, json_print
+from ..helpers import log_multi
+
+from .common import with_repository, with_archive, Highlander, define_exclusion_group
+
+from ..logger import create_logger
+
+logger = create_logger(__name__)
+
+
+class TarMixIn:
+    @with_repository(compatibility=(Manifest.Operation.READ,))
+    @with_archive
+    def do_export_tar(self, args, repository, manifest, key, archive):
+        """Export archive contents as a tarball"""
+        self.output_list = args.output_list
+
+        # A quick note about the general design of tar_filter and tarfile;
+        # The tarfile module of Python can provide some compression mechanisms
+        # by itself, using the builtin gzip, bz2 and lzma modules (and "tarmodes"
+        # such as "w:xz").
+        #
+        # Doing so would have three major drawbacks:
+        # For one the compressor runs on the same thread as the program using the
+        # tarfile, stealing valuable CPU time from Borg and thus reducing throughput.
+        # Then this limits the available options - what about lz4? Brotli? zstd?
+        # The third issue is that systems can ship more optimized versions than those
+        # built into Python, e.g. pigz or pxz, which can use more than one thread for
+        # compression.
+        #
+        # Therefore we externalize compression by using a filter program, which has
+        # none of these drawbacks. The only issue of using an external filter is
+        # that it has to be installed -- hardly a problem, considering that
+        # the decompressor must be installed as well to make use of the exported tarball!
+
+        filter = get_tar_filter(args.tarfile, decompress=False) if args.tar_filter == "auto" else args.tar_filter
+
+        tarstream = dash_open(args.tarfile, "wb")
+        tarstream_close = args.tarfile != "-"
+
+        with create_filter_process(filter, stream=tarstream, stream_close=tarstream_close, inbound=False) as _stream:
+            self._export_tar(args, archive, _stream)
+
+        return self.exit_code
+
+    def _export_tar(self, args, archive, tarstream):
+        matcher = self.build_matcher(args.patterns, args.paths)
+
+        progress = args.progress
+        output_list = args.output_list
+        strip_components = args.strip_components
+        hlm = HardLinkManager(id_type=bytes, info_type=str)  # hlid -> path
+
+        filter = self.build_filter(matcher, strip_components)
+
+        # The | (pipe) symbol instructs tarfile to use a streaming mode of operation
+        # where it never seeks on the passed fileobj.
+        tar_format = dict(GNU=tarfile.GNU_FORMAT, PAX=tarfile.PAX_FORMAT, BORG=tarfile.PAX_FORMAT)[args.tar_format]
+        tar = tarfile.open(fileobj=tarstream, mode="w|", format=tar_format)
+
+        if progress:
+            pi = ProgressIndicatorPercent(msg="%5.1f%% Processing: %s", step=0.1, msgid="extract")
+            pi.output("Calculating size")
+            extracted_size = sum(item.get_size() for item in archive.iter_items(filter))
+            pi.total = extracted_size
+        else:
+            pi = None
+
+        def item_content_stream(item):
+            """
+            Return a file-like object that reads from the chunks of *item*.
+            """
+            chunk_iterator = archive.pipeline.fetch_many([chunk_id for chunk_id, _ in item.chunks], is_preloaded=True)
+            if pi:
+                info = [remove_surrogates(item.path)]
+                return ChunkIteratorFileWrapper(
+                    chunk_iterator, lambda read_bytes: pi.show(increase=len(read_bytes), info=info)
+                )
+            else:
+                return ChunkIteratorFileWrapper(chunk_iterator)
+
+        def item_to_tarinfo(item, original_path):
+            """
+            Transform a Borg *item* into a tarfile.TarInfo object.
+
+            Return a tuple (tarinfo, stream), where stream may be a file-like object that represents
+            the file contents, if any, and is None otherwise. When *tarinfo* is None, the *item*
+            cannot be represented as a TarInfo object and should be skipped.
+            """
+            stream = None
+            tarinfo = tarfile.TarInfo()
+            tarinfo.name = item.path
+            tarinfo.mtime = item.mtime / 1e9
+            tarinfo.mode = stat.S_IMODE(item.mode)
+            tarinfo.uid = item.uid
+            tarinfo.gid = item.gid
+            tarinfo.uname = item.get("user", "")
+            tarinfo.gname = item.get("group", "")
+            # The linkname in tar has 2 uses:
+            # for symlinks it means the destination, while for hardlinks it refers to the file.
+            # Since hardlinks in tar have a different type code (LNKTYPE) the format might
+            # support hardlinking arbitrary objects (including symlinks and directories), but
+            # whether implementations actually support that is a whole different question...
+            tarinfo.linkname = ""
+
+            modebits = stat.S_IFMT(item.mode)
+            if modebits == stat.S_IFREG:
+                tarinfo.type = tarfile.REGTYPE
+                if "hlid" in item:
+                    linkname = hlm.retrieve(id=item.hlid)
+                    if linkname is not None:
+                        # the first hardlink was already added to the archive, add a tar-hardlink reference to it.
+                        tarinfo.type = tarfile.LNKTYPE
+                        tarinfo.linkname = linkname
+                    else:
+                        tarinfo.size = item.get_size()
+                        stream = item_content_stream(item)
+                        hlm.remember(id=item.hlid, info=item.path)
+                else:
+                    tarinfo.size = item.get_size()
+                    stream = item_content_stream(item)
+            elif modebits == stat.S_IFDIR:
+                tarinfo.type = tarfile.DIRTYPE
+            elif modebits == stat.S_IFLNK:
+                tarinfo.type = tarfile.SYMTYPE
+                tarinfo.linkname = item.source
+            elif modebits == stat.S_IFBLK:
+                tarinfo.type = tarfile.BLKTYPE
+                tarinfo.devmajor = os.major(item.rdev)
+                tarinfo.devminor = os.minor(item.rdev)
+            elif modebits == stat.S_IFCHR:
+                tarinfo.type = tarfile.CHRTYPE
+                tarinfo.devmajor = os.major(item.rdev)
+                tarinfo.devminor = os.minor(item.rdev)
+            elif modebits == stat.S_IFIFO:
+                tarinfo.type = tarfile.FIFOTYPE
+            else:
+                self.print_warning(
+                    "%s: unsupported file type %o for tar export", remove_surrogates(item.path), modebits
+                )
+                return None, stream
+            return tarinfo, stream
+
+        def item_to_paxheaders(format, item):
+            """
+            Transform (parts of) a Borg *item* into a pax_headers dict.
+            """
+            # PAX format
+            # ----------
+            # When using the PAX (POSIX) format, we can support some things that aren't possible
+            # with classic tar formats, including GNU tar, such as:
+            # - atime, ctime (DONE)
+            # - possibly Linux capabilities, security.* xattrs (TODO)
+            # - various additions supported by GNU tar in POSIX mode (TODO)
+            #
+            # BORG format
+            # -----------
+            # This is based on PAX, but additionally adds BORG.* pax headers.
+            # Additionally to the standard tar / PAX metadata and data, it transfers
+            # ALL borg item metadata in a BORG specific way.
+            #
+            ph = {}
+            # note: for mtime this is a bit redundant as it is already done by tarfile module,
+            #       but we just do it in our way to be consistent for sure.
+            for name in "atime", "ctime", "mtime":
+                if hasattr(item, name):
+                    ns = getattr(item, name)
+                    ph[name] = str(ns / 1e9)
+            if format == "BORG":  # BORG format additions
+                ph["BORG.item.version"] = "1"
+                # BORG.item.meta - just serialize all metadata we have:
+                meta_bin = msgpack.packb(item.as_dict())
+                meta_text = base64.b64encode(meta_bin).decode()
+                ph["BORG.item.meta"] = meta_text
+            return ph
+
+        for item in archive.iter_items(filter, preload=True):
+            orig_path = item.path
+            if strip_components:
+                item.path = os.sep.join(orig_path.split(os.sep)[strip_components:])
+            tarinfo, stream = item_to_tarinfo(item, orig_path)
+            if tarinfo:
+                if args.tar_format in ("BORG", "PAX"):
+                    tarinfo.pax_headers = item_to_paxheaders(args.tar_format, item)
+                if output_list:
+                    logging.getLogger("borg.output.list").info(remove_surrogates(orig_path))
+                tar.addfile(tarinfo, stream)
+
+        if pi:
+            pi.finish()
+
+        # This does not close the fileobj (tarstream) we passed to it -- a side effect of the | mode.
+        tar.close()
+
+        for pattern in matcher.get_unmatched_include_patterns():
+            self.print_warning("Include pattern '%s' never matched.", pattern)
+        return self.exit_code
+
+    @with_repository(cache=True, exclusive=True, compatibility=(Manifest.Operation.WRITE,))
+    def do_import_tar(self, args, repository, manifest, key, cache):
+        """Create a backup archive from a tarball"""
+        self.output_filter = args.output_filter
+        self.output_list = args.output_list
+
+        filter = get_tar_filter(args.tarfile, decompress=True) if args.tar_filter == "auto" else args.tar_filter
+
+        tarstream = dash_open(args.tarfile, "rb")
+        tarstream_close = args.tarfile != "-"
+
+        with create_filter_process(filter, stream=tarstream, stream_close=tarstream_close, inbound=True) as _stream:
+            self._import_tar(args, repository, manifest, key, cache, _stream)
+
+        return self.exit_code
+
+    def _import_tar(self, args, repository, manifest, key, cache, tarstream):
+        t0 = datetime.utcnow()
+        t0_monotonic = time.monotonic()
+
+        archive = Archive(
+            repository,
+            key,
+            manifest,
+            args.name,
+            cache=cache,
+            create=True,
+            checkpoint_interval=args.checkpoint_interval,
+            progress=args.progress,
+            chunker_params=args.chunker_params,
+            start=t0,
+            start_monotonic=t0_monotonic,
+            log_json=args.log_json,
+        )
+        cp = ChunksProcessor(
+            cache=cache,
+            key=key,
+            add_item=archive.add_item,
+            write_checkpoint=archive.write_checkpoint,
+            checkpoint_interval=args.checkpoint_interval,
+            rechunkify=False,
+        )
+        tfo = TarfileObjectProcessors(
+            cache=cache,
+            key=key,
+            process_file_chunks=cp.process_file_chunks,
+            add_item=archive.add_item,
+            chunker_params=args.chunker_params,
+            show_progress=args.progress,
+            log_json=args.log_json,
+            iec=args.iec,
+            file_status_printer=self.print_file_status,
+        )
+
+        tar = tarfile.open(fileobj=tarstream, mode="r|")
+
+        while True:
+            tarinfo = tar.next()
+            if not tarinfo:
+                break
+            if tarinfo.isreg():
+                status = tfo.process_file(tarinfo=tarinfo, status="A", type=stat.S_IFREG, tar=tar)
+                archive.stats.nfiles += 1
+            elif tarinfo.isdir():
+                status = tfo.process_dir(tarinfo=tarinfo, status="d", type=stat.S_IFDIR)
+            elif tarinfo.issym():
+                status = tfo.process_symlink(tarinfo=tarinfo, status="s", type=stat.S_IFLNK)
+            elif tarinfo.islnk():
+                # tar uses a hardlink model like: the first instance of a hardlink is stored as a regular file,
+                # later instances are special entries referencing back to the first instance.
+                status = tfo.process_hardlink(tarinfo=tarinfo, status="h", type=stat.S_IFREG)
+            elif tarinfo.isblk():
+                status = tfo.process_dev(tarinfo=tarinfo, status="b", type=stat.S_IFBLK)
+            elif tarinfo.ischr():
+                status = tfo.process_dev(tarinfo=tarinfo, status="c", type=stat.S_IFCHR)
+            elif tarinfo.isfifo():
+                status = tfo.process_fifo(tarinfo=tarinfo, status="f", type=stat.S_IFIFO)
+            else:
+                status = "E"
+                self.print_warning("%s: Unsupported tarinfo type %s", tarinfo.name, tarinfo.type)
+            self.print_file_status(status, tarinfo.name)
+
+        # This does not close the fileobj (tarstream) we passed to it -- a side effect of the | mode.
+        tar.close()
+
+        if args.progress:
+            archive.stats.show_progress(final=True)
+        archive.stats += tfo.stats
+        archive.save(comment=args.comment, timestamp=args.timestamp)
+        args.stats |= args.json
+        if args.stats:
+            if args.json:
+                json_print(basic_json_data(archive.manifest, cache=archive.cache, extra={"archive": archive}))
+            else:
+                log_multi(str(archive), str(archive.stats), logger=logging.getLogger("borg.output.stats"))
+
+    def build_parser_tar(self, subparsers, common_parser, mid_common_parser):
+
+        from .common import process_epilog
+
+        export_tar_epilog = process_epilog(
+            """
+        This command creates a tarball from an archive.
+
+        When giving '-' as the output FILE, Borg will write a tar stream to standard output.
+
+        By default (``--tar-filter=auto``) Borg will detect whether the FILE should be compressed
+        based on its file extension and pipe the tarball through an appropriate filter
+        before writing it to FILE:
+
+        - .tar.gz or .tgz: gzip
+        - .tar.bz2 or .tbz: bzip2
+        - .tar.xz or .txz: xz
+        - .tar.zstd: zstd
+        - .tar.lz4: lz4
+
+        Alternatively, a ``--tar-filter`` program may be explicitly specified. It should
+        read the uncompressed tar stream from stdin and write a compressed/filtered
+        tar stream to stdout.
+
+        Depending on the ``-tar-format`` option, these formats are created:
+
+        +--------------+---------------------------+----------------------------+
+        | --tar-format | Specification             | Metadata                   |
+        +--------------+---------------------------+----------------------------+
+        | BORG         | BORG specific, like PAX   | all as supported by borg   |
+        +--------------+---------------------------+----------------------------+
+        | PAX          | POSIX.1-2001 (pax) format | GNU + atime/ctime/mtime ns |
+        +--------------+---------------------------+----------------------------+
+        | GNU          | GNU tar format            | mtime s, no atime/ctime,   |
+        |              |                           | no ACLs/xattrs/bsdflags    |
+        +--------------+---------------------------+----------------------------+
+
+        A ``--sparse`` option (as found in borg extract) is not supported.
+
+        By default the entire archive is extracted but a subset of files and directories
+        can be selected by passing a list of ``PATHs`` as arguments.
+        The file selection can further be restricted by using the ``--exclude`` option.
+
+        For more help on include/exclude patterns, see the :ref:`borg_patterns` command output.
+
+        ``--progress`` can be slower than no progress display, since it makes one additional
+        pass over the archive metadata.
+        """
+        )
+        subparser = subparsers.add_parser(
+            "export-tar",
+            parents=[common_parser],
+            add_help=False,
+            description=self.do_export_tar.__doc__,
+            epilog=export_tar_epilog,
+            formatter_class=argparse.RawDescriptionHelpFormatter,
+            help="create tarball from archive",
+        )
+        subparser.set_defaults(func=self.do_export_tar)
+        subparser.add_argument(
+            "--tar-filter", dest="tar_filter", default="auto", help="filter program to pipe data through"
+        )
+        subparser.add_argument(
+            "--list", dest="output_list", action="store_true", help="output verbose list of items (files, dirs, ...)"
+        )
+        subparser.add_argument(
+            "--tar-format",
+            metavar="FMT",
+            dest="tar_format",
+            default="GNU",
+            choices=("BORG", "PAX", "GNU"),
+            help="select tar format: BORG, PAX or GNU",
+        )
+        subparser.add_argument("name", metavar="NAME", type=NameSpec, help="specify the archive name")
+        subparser.add_argument("tarfile", metavar="FILE", help='output tar file. "-" to write to stdout instead.')
+        subparser.add_argument(
+            "paths", metavar="PATH", nargs="*", type=str, help="paths to extract; patterns are supported"
+        )
+        define_exclusion_group(subparser, strip_components=True)
+
+        import_tar_epilog = process_epilog(
+            """
+        This command creates a backup archive from a tarball.
+
+        When giving '-' as path, Borg will read a tar stream from standard input.
+
+        By default (--tar-filter=auto) Borg will detect whether the file is compressed
+        based on its file extension and pipe the file through an appropriate filter:
+
+        - .tar.gz or .tgz: gzip -d
+        - .tar.bz2 or .tbz: bzip2 -d
+        - .tar.xz or .txz: xz -d
+        - .tar.zstd: zstd -d
+        - .tar.lz4: lz4 -d
+
+        Alternatively, a --tar-filter program may be explicitly specified. It should
+        read compressed data from stdin and output an uncompressed tar stream on
+        stdout.
+
+        Most documentation of borg create applies. Note that this command does not
+        support excluding files.
+
+        A ``--sparse`` option (as found in borg create) is not supported.
+
+        About tar formats and metadata conservation or loss, please see ``borg export-tar``.
+
+        import-tar reads these tar formats:
+
+        - BORG: borg specific (PAX-based)
+        - PAX: POSIX.1-2001
+        - GNU: GNU tar
+        - POSIX.1-1988 (ustar)
+        - UNIX V7 tar
+        - SunOS tar with extended attributes
+
+        """
+        )
+        subparser = subparsers.add_parser(
+            "import-tar",
+            parents=[common_parser],
+            add_help=False,
+            description=self.do_import_tar.__doc__,
+            epilog=import_tar_epilog,
+            formatter_class=argparse.RawDescriptionHelpFormatter,
+            help=self.do_import_tar.__doc__,
+        )
+        subparser.set_defaults(func=self.do_import_tar)
+        subparser.add_argument(
+            "--tar-filter",
+            dest="tar_filter",
+            default="auto",
+            action=Highlander,
+            help="filter program to pipe data through",
+        )
+        subparser.add_argument(
+            "-s",
+            "--stats",
+            dest="stats",
+            action="store_true",
+            default=False,
+            help="print statistics for the created archive",
+        )
+        subparser.add_argument(
+            "--list",
+            dest="output_list",
+            action="store_true",
+            default=False,
+            help="output verbose list of items (files, dirs, ...)",
+        )
+        subparser.add_argument(
+            "--filter",
+            dest="output_filter",
+            metavar="STATUSCHARS",
+            action=Highlander,
+            help="only display items with the given status characters",
+        )
+        subparser.add_argument("--json", action="store_true", help="output stats as JSON (implies --stats)")
+
+        archive_group = subparser.add_argument_group("Archive options")
+        archive_group.add_argument(
+            "--comment", dest="comment", metavar="COMMENT", default="", help="add a comment text to the archive"
+        )
+        archive_group.add_argument(
+            "--timestamp",
+            dest="timestamp",
+            type=timestamp,
+            default=None,
+            metavar="TIMESTAMP",
+            help="manually specify the archive creation date/time (UTC, yyyy-mm-ddThh:mm:ss format). "
+            "alternatively, give a reference file/directory.",
+        )
+        archive_group.add_argument(
+            "-c",
+            "--checkpoint-interval",
+            dest="checkpoint_interval",
+            type=int,
+            default=1800,
+            metavar="SECONDS",
+            help="write checkpoint every SECONDS seconds (Default: 1800)",
+        )
+        archive_group.add_argument(
+            "--chunker-params",
+            dest="chunker_params",
+            action=Highlander,
+            type=ChunkerParams,
+            default=CHUNKER_PARAMS,
+            metavar="PARAMS",
+            help="specify the chunker parameters (ALGO, CHUNK_MIN_EXP, CHUNK_MAX_EXP, "
+            "HASH_MASK_BITS, HASH_WINDOW_SIZE). default: %s,%d,%d,%d,%d" % CHUNKER_PARAMS,
+        )
+        archive_group.add_argument(
+            "-C",
+            "--compression",
+            metavar="COMPRESSION",
+            dest="compression",
+            type=CompressionSpec,
+            default=CompressionSpec("lz4"),
+            help="select compression algorithm, see the output of the " '"borg help compression" command for details.',
+        )
+
+        subparser.add_argument("name", metavar="NAME", type=NameSpec, help="specify the archive name")
+        subparser.add_argument("tarfile", metavar="TARFILE", help='input tar file. "-" to read from stdin instead.')

From 5ea9fb73dbcb4216bc91d80665bbad0061579f6c Mon Sep 17 00:00:00 2001
From: Thomas Waldmann <tw@waldmann-edv.de>
Date: Fri, 8 Jul 2022 02:53:17 +0200
Subject: [PATCH 120/160] move benchmark commands to archiver.benchmarks

---
 setup.cfg                       |   1 +
 src/borg/archiver/__init__.py   | 304 +------------------------------
 src/borg/archiver/benchmarks.py | 312 ++++++++++++++++++++++++++++++++
 3 files changed, 318 insertions(+), 299 deletions(-)
 create mode 100644 src/borg/archiver/benchmarks.py

diff --git a/setup.cfg b/setup.cfg
index bf668fc4e..ec59f2b53 100644
--- a/setup.cfg
+++ b/setup.cfg
@@ -117,6 +117,7 @@ per_file_ignores =
     docs/conf.py:E121,E126,E265,E305,E401,E402
     src/borg/archive.py:E122,E125,E127,E402,E501,F401,F405,W504
     src/borg/archiver/__init__.py:E402,E501,E722,E741,F405
+    src/borg/archiver/benchmarks.py:F405
     src/borg/archiver/common.py:E501,F405
     src/borg/archiver/debug.py:F405
     src/borg/archiver/tar.py:F405
diff --git a/src/borg/archiver/__init__.py b/src/borg/archiver/__init__.py
index 8eabb5f4e..29752977b 100644
--- a/src/borg/archiver/__init__.py
+++ b/src/borg/archiver/__init__.py
@@ -16,14 +16,12 @@ try:
     import os
     import re
     import shlex
-    import shutil
     import signal
     import stat
     import subprocess
     import textwrap
     import time
     from binascii import unhexlify
-    from contextlib import contextmanager
     from datetime import datetime, timedelta
     from io import TextIOWrapper
 
@@ -40,7 +38,7 @@ try:
     from ..cache import Cache, assert_secure, SecurityManager
     from ..constants import *  # NOQA
     from ..compress import CompressionSpec
-    from ..crypto.key import FlexiKey, key_creator, key_argument_names, tam_required_file
+    from ..crypto.key import key_creator, key_argument_names, tam_required_file
     from ..crypto.key import AESOCBRepoKey, CHPORepoKey, Blake2AESOCBRepoKey, Blake2CHPORepoKey
     from ..crypto.key import AESOCBKeyfileKey, CHPOKeyfileKey, Blake2AESOCBKeyfileKey, Blake2CHPOKeyfileKey
     from ..crypto.keymanager import KeyManager
@@ -71,8 +69,7 @@ try:
     from ..helpers import iter_separated
     from ..nanorst import rst_to_terminal
     from ..patterns import PatternMatcher
-    from ..item import Item
-    from ..platform import get_flags, SyncFile
+    from ..platform import get_flags
     from ..platform import uid2user, gid2group
     from ..remote import RepositoryServer, RemoteRepository, cache_if_remote
     from ..selftest import selftest
@@ -110,11 +107,12 @@ def get_func(args):
     raise Exception("expected func attributes not found")
 
 
+from .benchmarks import BenchmarkMixIn
 from .debug import DebugMixIn
 from .tar import TarMixIn
 
 
-class Archiver(DebugMixIn, TarMixIn):
+class Archiver(DebugMixIn, TarMixIn, BenchmarkMixIn):
     def __init__(self, lock_wait=None, prog=None):
         self.exit_code = EXIT_SUCCESS
         self.lock_wait = lock_wait
@@ -446,208 +444,6 @@ class Archiver(DebugMixIn, TarMixIn):
             manager.import_keyfile(args)
         return EXIT_SUCCESS
 
-    def do_benchmark_crud(self, args):
-        """Benchmark Create, Read, Update, Delete for archives."""
-
-        def measurement_run(repo, path):
-            compression = "--compression=none"
-            # measure create perf (without files cache to always have it chunking)
-            t_start = time.monotonic()
-            rc = self.do_create(
-                self.parse_args(
-                    [f"--repo={repo}", "create", compression, "--files-cache=disabled", "borg-benchmark-crud1", path]
-                )
-            )
-            t_end = time.monotonic()
-            dt_create = t_end - t_start
-            assert rc == 0
-            # now build files cache
-            rc1 = self.do_create(
-                self.parse_args([f"--repo={repo}", "create", compression, "borg-benchmark-crud2", path])
-            )
-            rc2 = self.do_delete(self.parse_args([f"--repo={repo}", "delete", "-a", "borg-benchmark-crud2"]))
-            assert rc1 == rc2 == 0
-            # measure a no-change update (archive1 is still present)
-            t_start = time.monotonic()
-            rc1 = self.do_create(
-                self.parse_args([f"--repo={repo}", "create", compression, "borg-benchmark-crud3", path])
-            )
-            t_end = time.monotonic()
-            dt_update = t_end - t_start
-            rc2 = self.do_delete(self.parse_args([f"--repo={repo}", "delete", "-a", "borg-benchmark-crud3"]))
-            assert rc1 == rc2 == 0
-            # measure extraction (dry-run: without writing result to disk)
-            t_start = time.monotonic()
-            rc = self.do_extract(self.parse_args([f"--repo={repo}", "extract", "borg-benchmark-crud1", "--dry-run"]))
-            t_end = time.monotonic()
-            dt_extract = t_end - t_start
-            assert rc == 0
-            # measure archive deletion (of LAST present archive with the data)
-            t_start = time.monotonic()
-            rc = self.do_delete(self.parse_args([f"--repo={repo}", "delete", "-a", "borg-benchmark-crud1"]))
-            t_end = time.monotonic()
-            dt_delete = t_end - t_start
-            assert rc == 0
-            return dt_create, dt_update, dt_extract, dt_delete
-
-        @contextmanager
-        def test_files(path, count, size, random):
-            try:
-                path = os.path.join(path, "borg-test-data")
-                os.makedirs(path)
-                z_buff = None if random else memoryview(zeros)[:size] if size <= len(zeros) else b"\0" * size
-                for i in range(count):
-                    fname = os.path.join(path, "file_%d" % i)
-                    data = z_buff if not random else os.urandom(size)
-                    with SyncFile(fname, binary=True) as fd:  # used for posix_fadvise's sake
-                        fd.write(data)
-                yield path
-            finally:
-                shutil.rmtree(path)
-
-        if "_BORG_BENCHMARK_CRUD_TEST" in os.environ:
-            tests = [("Z-TEST", 1, 1, False), ("R-TEST", 1, 1, True)]
-        else:
-            tests = [
-                ("Z-BIG", 10, 100000000, False),
-                ("R-BIG", 10, 100000000, True),
-                ("Z-MEDIUM", 1000, 1000000, False),
-                ("R-MEDIUM", 1000, 1000000, True),
-                ("Z-SMALL", 10000, 10000, False),
-                ("R-SMALL", 10000, 10000, True),
-            ]
-
-        for msg, count, size, random in tests:
-            with test_files(args.path, count, size, random) as path:
-                dt_create, dt_update, dt_extract, dt_delete = measurement_run(args.location.canonical_path(), path)
-            total_size_MB = count * size / 1e06
-            file_size_formatted = format_file_size(size)
-            content = "random" if random else "all-zero"
-            fmt = "%s-%-10s %9.2f MB/s (%d * %s %s files: %.2fs)"
-            print(fmt % ("C", msg, total_size_MB / dt_create, count, file_size_formatted, content, dt_create))
-            print(fmt % ("R", msg, total_size_MB / dt_extract, count, file_size_formatted, content, dt_extract))
-            print(fmt % ("U", msg, total_size_MB / dt_update, count, file_size_formatted, content, dt_update))
-            print(fmt % ("D", msg, total_size_MB / dt_delete, count, file_size_formatted, content, dt_delete))
-
-        return 0
-
-    def do_benchmark_cpu(self, args):
-        """Benchmark CPU bound operations."""
-        from timeit import timeit
-
-        random_10M = os.urandom(10 * 1000 * 1000)
-        key_256 = os.urandom(32)
-        key_128 = os.urandom(16)
-        key_96 = os.urandom(12)
-
-        import io
-        from .chunker import get_chunker
-
-        print("Chunkers =======================================================")
-        size = "1GB"
-
-        def chunkit(chunker_name, *args, **kwargs):
-            with io.BytesIO(random_10M) as data_file:
-                ch = get_chunker(chunker_name, *args, **kwargs)
-                for _ in ch.chunkify(fd=data_file):
-                    pass
-
-        for spec, func in [
-            ("buzhash,19,23,21,4095", lambda: chunkit("buzhash", 19, 23, 21, 4095, seed=0)),
-            ("fixed,1048576", lambda: chunkit("fixed", 1048576, sparse=False)),
-        ]:
-            print(f"{spec:<24} {size:<10} {timeit(func, number=100):.3f}s")
-
-        from .checksums import crc32, xxh64
-
-        print("Non-cryptographic checksums / hashes ===========================")
-        size = "1GB"
-        tests = [("xxh64", lambda: xxh64(random_10M)), ("crc32 (zlib)", lambda: crc32(random_10M))]
-        for spec, func in tests:
-            print(f"{spec:<24} {size:<10} {timeit(func, number=100):.3f}s")
-
-        from .crypto.low_level import hmac_sha256, blake2b_256
-
-        print("Cryptographic hashes / MACs ====================================")
-        size = "1GB"
-        for spec, func in [
-            ("hmac-sha256", lambda: hmac_sha256(key_256, random_10M)),
-            ("blake2b-256", lambda: blake2b_256(key_256, random_10M)),
-        ]:
-            print(f"{spec:<24} {size:<10} {timeit(func, number=100):.3f}s")
-
-        from .crypto.low_level import AES256_CTR_BLAKE2b, AES256_CTR_HMAC_SHA256
-        from .crypto.low_level import AES256_OCB, CHACHA20_POLY1305
-
-        print("Encryption =====================================================")
-        size = "1GB"
-
-        tests = [
-            (
-                "aes-256-ctr-hmac-sha256",
-                lambda: AES256_CTR_HMAC_SHA256(key_256, key_256, iv=key_128, header_len=1, aad_offset=1).encrypt(
-                    random_10M, header=b"X"
-                ),
-            ),
-            (
-                "aes-256-ctr-blake2b",
-                lambda: AES256_CTR_BLAKE2b(key_256 * 4, key_256, iv=key_128, header_len=1, aad_offset=1).encrypt(
-                    random_10M, header=b"X"
-                ),
-            ),
-            (
-                "aes-256-ocb",
-                lambda: AES256_OCB(key_256, iv=key_96, header_len=1, aad_offset=1).encrypt(random_10M, header=b"X"),
-            ),
-            (
-                "chacha20-poly1305",
-                lambda: CHACHA20_POLY1305(key_256, iv=key_96, header_len=1, aad_offset=1).encrypt(
-                    random_10M, header=b"X"
-                ),
-            ),
-        ]
-        for spec, func in tests:
-            print(f"{spec:<24} {size:<10} {timeit(func, number=100):.3f}s")
-
-        print("KDFs (slow is GOOD, use argon2!) ===============================")
-        count = 5
-        for spec, func in [
-            ("pbkdf2", lambda: FlexiKey.pbkdf2("mypassphrase", b"salt" * 8, PBKDF2_ITERATIONS, 32)),
-            ("argon2", lambda: FlexiKey.argon2("mypassphrase", 64, b"S" * ARGON2_SALT_BYTES, **ARGON2_ARGS)),
-        ]:
-            print(f"{spec:<24} {count:<10} {timeit(func, number=count):.3f}s")
-
-        from .compress import CompressionSpec
-
-        print("Compression ====================================================")
-        for spec in [
-            "lz4",
-            "zstd,1",
-            "zstd,3",
-            "zstd,5",
-            "zstd,10",
-            "zstd,16",
-            "zstd,22",
-            "zlib,0",
-            "zlib,6",
-            "zlib,9",
-            "lzma,0",
-            "lzma,6",
-            "lzma,9",
-        ]:
-            compressor = CompressionSpec(spec).compressor
-            size = "0.1GB"
-            print(f"{spec:<12} {size:<10} {timeit(lambda: compressor.compress(random_10M), number=10):.3f}s")
-
-        print("msgpack ========================================================")
-        item = Item(path="/foo/bar/baz", mode=660, mtime=1234567)
-        items = [item.as_dict()] * 1000
-        size = "100k Items"
-        spec = "msgpack"
-        print(f"{spec:<12} {size:<10} {timeit(lambda: msgpack.packb(items), number=100):.3f}s")
-
-        return 0
-
     @with_repository(fake="dry_run", exclusive=True, compatibility=(Manifest.Operation.WRITE,))
     def do_create(self, args, repository, manifest=None, key=None):
         """Create new archive"""
@@ -2757,97 +2553,7 @@ class Archiver(DebugMixIn, TarMixIn):
 
         subparsers = parser.add_subparsers(title="required arguments", metavar="<command>")
 
-        # borg benchmark
-        benchmark_epilog = process_epilog("These commands do various benchmarks.")
-
-        subparser = subparsers.add_parser(
-            "benchmark",
-            parents=[mid_common_parser],
-            add_help=False,
-            description="benchmark command",
-            epilog=benchmark_epilog,
-            formatter_class=argparse.RawDescriptionHelpFormatter,
-            help="benchmark command",
-        )
-
-        benchmark_parsers = subparser.add_subparsers(title="required arguments", metavar="<command>")
-        subparser.set_defaults(fallback_func=functools.partial(self.do_subcommand_help, subparser))
-
-        bench_crud_epilog = process_epilog(
-            """
-        This command benchmarks borg CRUD (create, read, update, delete) operations.
-
-        It creates input data below the given PATH and backups this data into the given REPO.
-        The REPO must already exist (it could be a fresh empty repo or an existing repo, the
-        command will create / read / update / delete some archives named borg-benchmark-crud\\* there.
-
-        Make sure you have free space there, you'll need about 1GB each (+ overhead).
-
-        If your repository is encrypted and borg needs a passphrase to unlock the key, use::
-
-            BORG_PASSPHRASE=mysecret borg benchmark crud REPO PATH
-
-        Measurements are done with different input file sizes and counts.
-        The file contents are very artificial (either all zero or all random),
-        thus the measurement results do not necessarily reflect performance with real data.
-        Also, due to the kind of content used, no compression is used in these benchmarks.
-
-        C- == borg create (1st archive creation, no compression, do not use files cache)
-              C-Z- == all-zero files. full dedup, this is primarily measuring reader/chunker/hasher.
-              C-R- == random files. no dedup, measuring throughput through all processing stages.
-
-        R- == borg extract (extract archive, dry-run, do everything, but do not write files to disk)
-              R-Z- == all zero files. Measuring heavily duplicated files.
-              R-R- == random files. No duplication here, measuring throughput through all processing
-              stages, except writing to disk.
-
-        U- == borg create (2nd archive creation of unchanged input files, measure files cache speed)
-              The throughput value is kind of virtual here, it does not actually read the file.
-              U-Z- == needs to check the 2 all-zero chunks' existence in the repo.
-              U-R- == needs to check existence of a lot of different chunks in the repo.
-
-        D- == borg delete archive (delete last remaining archive, measure deletion + compaction)
-              D-Z- == few chunks to delete / few segments to compact/remove.
-              D-R- == many chunks to delete / many segments to compact/remove.
-
-        Please note that there might be quite some variance in these measurements.
-        Try multiple measurements and having a otherwise idle machine (and network, if you use it).
-        """
-        )
-        subparser = benchmark_parsers.add_parser(
-            "crud",
-            parents=[common_parser],
-            add_help=False,
-            description=self.do_benchmark_crud.__doc__,
-            epilog=bench_crud_epilog,
-            formatter_class=argparse.RawDescriptionHelpFormatter,
-            help="benchmarks borg CRUD (create, extract, update, delete).",
-        )
-        subparser.set_defaults(func=self.do_benchmark_crud)
-
-        subparser.add_argument("path", metavar="PATH", help="path were to create benchmark input data")
-
-        bench_cpu_epilog = process_epilog(
-            """
-        This command benchmarks misc. CPU bound borg operations.
-
-        It creates input data in memory, runs the operation and then displays throughput.
-        To reduce outside influence on the timings, please make sure to run this with:
-
-        - an otherwise as idle as possible machine
-        - enough free memory so there will be no slow down due to paging activity
-        """
-        )
-        subparser = benchmark_parsers.add_parser(
-            "cpu",
-            parents=[common_parser],
-            add_help=False,
-            description=self.do_benchmark_cpu.__doc__,
-            epilog=bench_cpu_epilog,
-            formatter_class=argparse.RawDescriptionHelpFormatter,
-            help="benchmarks borg CPU bound operations.",
-        )
-        subparser.set_defaults(func=self.do_benchmark_cpu)
+        self.build_parser_benchmarks(subparsers, common_parser, mid_common_parser)
 
         # borg break-lock
         break_lock_epilog = process_epilog(
diff --git a/src/borg/archiver/benchmarks.py b/src/borg/archiver/benchmarks.py
new file mode 100644
index 000000000..0669cbed8
--- /dev/null
+++ b/src/borg/archiver/benchmarks.py
@@ -0,0 +1,312 @@
+import argparse
+from contextlib import contextmanager
+import functools
+import os
+import shutil
+import time
+
+from ..constants import *  # NOQA
+from ..crypto.key import FlexiKey
+from ..helpers import format_file_size
+from ..helpers import msgpack
+from ..item import Item
+from ..platform import SyncFile
+
+
+class BenchmarkMixIn:
+    def do_benchmark_crud(self, args):
+        """Benchmark Create, Read, Update, Delete for archives."""
+
+        def measurement_run(repo, path):
+            compression = "--compression=none"
+            # measure create perf (without files cache to always have it chunking)
+            t_start = time.monotonic()
+            rc = self.do_create(
+                self.parse_args(
+                    [f"--repo={repo}", "create", compression, "--files-cache=disabled", "borg-benchmark-crud1", path]
+                )
+            )
+            t_end = time.monotonic()
+            dt_create = t_end - t_start
+            assert rc == 0
+            # now build files cache
+            rc1 = self.do_create(
+                self.parse_args([f"--repo={repo}", "create", compression, "borg-benchmark-crud2", path])
+            )
+            rc2 = self.do_delete(self.parse_args([f"--repo={repo}", "delete", "-a", "borg-benchmark-crud2"]))
+            assert rc1 == rc2 == 0
+            # measure a no-change update (archive1 is still present)
+            t_start = time.monotonic()
+            rc1 = self.do_create(
+                self.parse_args([f"--repo={repo}", "create", compression, "borg-benchmark-crud3", path])
+            )
+            t_end = time.monotonic()
+            dt_update = t_end - t_start
+            rc2 = self.do_delete(self.parse_args([f"--repo={repo}", "delete", "-a", "borg-benchmark-crud3"]))
+            assert rc1 == rc2 == 0
+            # measure extraction (dry-run: without writing result to disk)
+            t_start = time.monotonic()
+            rc = self.do_extract(self.parse_args([f"--repo={repo}", "extract", "borg-benchmark-crud1", "--dry-run"]))
+            t_end = time.monotonic()
+            dt_extract = t_end - t_start
+            assert rc == 0
+            # measure archive deletion (of LAST present archive with the data)
+            t_start = time.monotonic()
+            rc = self.do_delete(self.parse_args([f"--repo={repo}", "delete", "-a", "borg-benchmark-crud1"]))
+            t_end = time.monotonic()
+            dt_delete = t_end - t_start
+            assert rc == 0
+            return dt_create, dt_update, dt_extract, dt_delete
+
+        @contextmanager
+        def test_files(path, count, size, random):
+            try:
+                path = os.path.join(path, "borg-test-data")
+                os.makedirs(path)
+                z_buff = None if random else memoryview(zeros)[:size] if size <= len(zeros) else b"\0" * size
+                for i in range(count):
+                    fname = os.path.join(path, "file_%d" % i)
+                    data = z_buff if not random else os.urandom(size)
+                    with SyncFile(fname, binary=True) as fd:  # used for posix_fadvise's sake
+                        fd.write(data)
+                yield path
+            finally:
+                shutil.rmtree(path)
+
+        if "_BORG_BENCHMARK_CRUD_TEST" in os.environ:
+            tests = [("Z-TEST", 1, 1, False), ("R-TEST", 1, 1, True)]
+        else:
+            tests = [
+                ("Z-BIG", 10, 100000000, False),
+                ("R-BIG", 10, 100000000, True),
+                ("Z-MEDIUM", 1000, 1000000, False),
+                ("R-MEDIUM", 1000, 1000000, True),
+                ("Z-SMALL", 10000, 10000, False),
+                ("R-SMALL", 10000, 10000, True),
+            ]
+
+        for msg, count, size, random in tests:
+            with test_files(args.path, count, size, random) as path:
+                dt_create, dt_update, dt_extract, dt_delete = measurement_run(args.location.canonical_path(), path)
+            total_size_MB = count * size / 1e06
+            file_size_formatted = format_file_size(size)
+            content = "random" if random else "all-zero"
+            fmt = "%s-%-10s %9.2f MB/s (%d * %s %s files: %.2fs)"
+            print(fmt % ("C", msg, total_size_MB / dt_create, count, file_size_formatted, content, dt_create))
+            print(fmt % ("R", msg, total_size_MB / dt_extract, count, file_size_formatted, content, dt_extract))
+            print(fmt % ("U", msg, total_size_MB / dt_update, count, file_size_formatted, content, dt_update))
+            print(fmt % ("D", msg, total_size_MB / dt_delete, count, file_size_formatted, content, dt_delete))
+
+        return 0
+
+    def do_benchmark_cpu(self, args):
+        """Benchmark CPU bound operations."""
+        from timeit import timeit
+
+        random_10M = os.urandom(10 * 1000 * 1000)
+        key_256 = os.urandom(32)
+        key_128 = os.urandom(16)
+        key_96 = os.urandom(12)
+
+        import io
+        from ..chunker import get_chunker
+
+        print("Chunkers =======================================================")
+        size = "1GB"
+
+        def chunkit(chunker_name, *args, **kwargs):
+            with io.BytesIO(random_10M) as data_file:
+                ch = get_chunker(chunker_name, *args, **kwargs)
+                for _ in ch.chunkify(fd=data_file):
+                    pass
+
+        for spec, func in [
+            ("buzhash,19,23,21,4095", lambda: chunkit("buzhash", 19, 23, 21, 4095, seed=0)),
+            ("fixed,1048576", lambda: chunkit("fixed", 1048576, sparse=False)),
+        ]:
+            print(f"{spec:<24} {size:<10} {timeit(func, number=100):.3f}s")
+
+        from ..checksums import crc32, xxh64
+
+        print("Non-cryptographic checksums / hashes ===========================")
+        size = "1GB"
+        tests = [("xxh64", lambda: xxh64(random_10M)), ("crc32 (zlib)", lambda: crc32(random_10M))]
+        for spec, func in tests:
+            print(f"{spec:<24} {size:<10} {timeit(func, number=100):.3f}s")
+
+        from ..crypto.low_level import hmac_sha256, blake2b_256
+
+        print("Cryptographic hashes / MACs ====================================")
+        size = "1GB"
+        for spec, func in [
+            ("hmac-sha256", lambda: hmac_sha256(key_256, random_10M)),
+            ("blake2b-256", lambda: blake2b_256(key_256, random_10M)),
+        ]:
+            print(f"{spec:<24} {size:<10} {timeit(func, number=100):.3f}s")
+
+        from ..crypto.low_level import AES256_CTR_BLAKE2b, AES256_CTR_HMAC_SHA256
+        from ..crypto.low_level import AES256_OCB, CHACHA20_POLY1305
+
+        print("Encryption =====================================================")
+        size = "1GB"
+
+        tests = [
+            (
+                "aes-256-ctr-hmac-sha256",
+                lambda: AES256_CTR_HMAC_SHA256(key_256, key_256, iv=key_128, header_len=1, aad_offset=1).encrypt(
+                    random_10M, header=b"X"
+                ),
+            ),
+            (
+                "aes-256-ctr-blake2b",
+                lambda: AES256_CTR_BLAKE2b(key_256 * 4, key_256, iv=key_128, header_len=1, aad_offset=1).encrypt(
+                    random_10M, header=b"X"
+                ),
+            ),
+            (
+                "aes-256-ocb",
+                lambda: AES256_OCB(key_256, iv=key_96, header_len=1, aad_offset=1).encrypt(random_10M, header=b"X"),
+            ),
+            (
+                "chacha20-poly1305",
+                lambda: CHACHA20_POLY1305(key_256, iv=key_96, header_len=1, aad_offset=1).encrypt(
+                    random_10M, header=b"X"
+                ),
+            ),
+        ]
+        for spec, func in tests:
+            print(f"{spec:<24} {size:<10} {timeit(func, number=100):.3f}s")
+
+        print("KDFs (slow is GOOD, use argon2!) ===============================")
+        count = 5
+        for spec, func in [
+            ("pbkdf2", lambda: FlexiKey.pbkdf2("mypassphrase", b"salt" * 8, PBKDF2_ITERATIONS, 32)),
+            ("argon2", lambda: FlexiKey.argon2("mypassphrase", 64, b"S" * ARGON2_SALT_BYTES, **ARGON2_ARGS)),
+        ]:
+            print(f"{spec:<24} {count:<10} {timeit(func, number=count):.3f}s")
+
+        from ..compress import CompressionSpec
+
+        print("Compression ====================================================")
+        for spec in [
+            "lz4",
+            "zstd,1",
+            "zstd,3",
+            "zstd,5",
+            "zstd,10",
+            "zstd,16",
+            "zstd,22",
+            "zlib,0",
+            "zlib,6",
+            "zlib,9",
+            "lzma,0",
+            "lzma,6",
+            "lzma,9",
+        ]:
+            compressor = CompressionSpec(spec).compressor
+            size = "0.1GB"
+            print(f"{spec:<12} {size:<10} {timeit(lambda: compressor.compress(random_10M), number=10):.3f}s")
+
+        print("msgpack ========================================================")
+        item = Item(path="/foo/bar/baz", mode=660, mtime=1234567)
+        items = [item.as_dict()] * 1000
+        size = "100k Items"
+        spec = "msgpack"
+        print(f"{spec:<12} {size:<10} {timeit(lambda: msgpack.packb(items), number=100):.3f}s")
+
+        return 0
+
+    def build_parser_benchmarks(self, subparsers, common_parser, mid_common_parser):
+
+        from .common import process_epilog
+
+        benchmark_epilog = process_epilog("These commands do various benchmarks.")
+
+        subparser = subparsers.add_parser(
+            "benchmark",
+            parents=[mid_common_parser],
+            add_help=False,
+            description="benchmark command",
+            epilog=benchmark_epilog,
+            formatter_class=argparse.RawDescriptionHelpFormatter,
+            help="benchmark command",
+        )
+
+        benchmark_parsers = subparser.add_subparsers(title="required arguments", metavar="<command>")
+        subparser.set_defaults(fallback_func=functools.partial(self.do_subcommand_help, subparser))
+
+        bench_crud_epilog = process_epilog(
+            """
+        This command benchmarks borg CRUD (create, read, update, delete) operations.
+
+        It creates input data below the given PATH and backups this data into the given REPO.
+        The REPO must already exist (it could be a fresh empty repo or an existing repo, the
+        command will create / read / update / delete some archives named borg-benchmark-crud\\* there.
+
+        Make sure you have free space there, you'll need about 1GB each (+ overhead).
+
+        If your repository is encrypted and borg needs a passphrase to unlock the key, use::
+
+            BORG_PASSPHRASE=mysecret borg benchmark crud REPO PATH
+
+        Measurements are done with different input file sizes and counts.
+        The file contents are very artificial (either all zero or all random),
+        thus the measurement results do not necessarily reflect performance with real data.
+        Also, due to the kind of content used, no compression is used in these benchmarks.
+
+        C- == borg create (1st archive creation, no compression, do not use files cache)
+              C-Z- == all-zero files. full dedup, this is primarily measuring reader/chunker/hasher.
+              C-R- == random files. no dedup, measuring throughput through all processing stages.
+
+        R- == borg extract (extract archive, dry-run, do everything, but do not write files to disk)
+              R-Z- == all zero files. Measuring heavily duplicated files.
+              R-R- == random files. No duplication here, measuring throughput through all processing
+              stages, except writing to disk.
+
+        U- == borg create (2nd archive creation of unchanged input files, measure files cache speed)
+              The throughput value is kind of virtual here, it does not actually read the file.
+              U-Z- == needs to check the 2 all-zero chunks' existence in the repo.
+              U-R- == needs to check existence of a lot of different chunks in the repo.
+
+        D- == borg delete archive (delete last remaining archive, measure deletion + compaction)
+              D-Z- == few chunks to delete / few segments to compact/remove.
+              D-R- == many chunks to delete / many segments to compact/remove.
+
+        Please note that there might be quite some variance in these measurements.
+        Try multiple measurements and having a otherwise idle machine (and network, if you use it).
+        """
+        )
+        subparser = benchmark_parsers.add_parser(
+            "crud",
+            parents=[common_parser],
+            add_help=False,
+            description=self.do_benchmark_crud.__doc__,
+            epilog=bench_crud_epilog,
+            formatter_class=argparse.RawDescriptionHelpFormatter,
+            help="benchmarks borg CRUD (create, extract, update, delete).",
+        )
+        subparser.set_defaults(func=self.do_benchmark_crud)
+
+        subparser.add_argument("path", metavar="PATH", help="path were to create benchmark input data")
+
+        bench_cpu_epilog = process_epilog(
+            """
+        This command benchmarks misc. CPU bound borg operations.
+
+        It creates input data in memory, runs the operation and then displays throughput.
+        To reduce outside influence on the timings, please make sure to run this with:
+
+        - an otherwise as idle as possible machine
+        - enough free memory so there will be no slow down due to paging activity
+        """
+        )
+        subparser = benchmark_parsers.add_parser(
+            "cpu",
+            parents=[common_parser],
+            add_help=False,
+            description=self.do_benchmark_cpu.__doc__,
+            epilog=bench_cpu_epilog,
+            formatter_class=argparse.RawDescriptionHelpFormatter,
+            help="benchmarks borg CPU bound operations.",
+        )
+        subparser.set_defaults(func=self.do_benchmark_cpu)

From af2ee7aeb13a7a09db5bd6c791a253adccea37c9 Mon Sep 17 00:00:00 2001
From: Thomas Waldmann <tw@waldmann-edv.de>
Date: Fri, 8 Jul 2022 03:14:38 +0200
Subject: [PATCH 121/160] move key commands to archiver.keys

---
 setup.cfg                     |   1 +
 src/borg/archiver/__init__.py | 302 +-------------------------------
 src/borg/archiver/keys.py     | 316 ++++++++++++++++++++++++++++++++++
 3 files changed, 320 insertions(+), 299 deletions(-)
 create mode 100644 src/borg/archiver/keys.py

diff --git a/setup.cfg b/setup.cfg
index ec59f2b53..61b61074f 100644
--- a/setup.cfg
+++ b/setup.cfg
@@ -120,6 +120,7 @@ per_file_ignores =
     src/borg/archiver/benchmarks.py:F405
     src/borg/archiver/common.py:E501,F405
     src/borg/archiver/debug.py:F405
+    src/borg/archiver/keys.py:F405
     src/borg/archiver/tar.py:F405
     src/borg/cache.py:E127,E128,E402,E501,E722,W504
     src/borg/fuse.py:E402,E501,E722,W504
diff --git a/src/borg/archiver/__init__.py b/src/borg/archiver/__init__.py
index 29752977b..1cd1b28c4 100644
--- a/src/borg/archiver/__init__.py
+++ b/src/borg/archiver/__init__.py
@@ -39,9 +39,6 @@ try:
     from ..constants import *  # NOQA
     from ..compress import CompressionSpec
     from ..crypto.key import key_creator, key_argument_names, tam_required_file
-    from ..crypto.key import AESOCBRepoKey, CHPORepoKey, Blake2AESOCBRepoKey, Blake2CHPORepoKey
-    from ..crypto.key import AESOCBKeyfileKey, CHPOKeyfileKey, Blake2AESOCBKeyfileKey, Blake2CHPOKeyfileKey
-    from ..crypto.keymanager import KeyManager
     from ..helpers import EXIT_SUCCESS, EXIT_WARNING, EXIT_ERROR, EXIT_SIGNAL_BASE
     from ..helpers import Error, NoManifestError, set_ec
     from ..helpers import positive_int_validator, location_validator, archivename_validator, ChunkerParams, Location
@@ -109,10 +106,11 @@ def get_func(args):
 
 from .benchmarks import BenchmarkMixIn
 from .debug import DebugMixIn
+from .keys import KeysMixIn
 from .tar import TarMixIn
 
 
-class Archiver(DebugMixIn, TarMixIn, BenchmarkMixIn):
+class Archiver(DebugMixIn, TarMixIn, BenchmarkMixIn, KeysMixIn):
     def __init__(self, lock_wait=None, prog=None):
         self.exit_code = EXIT_SUCCESS
         self.lock_wait = lock_wait
@@ -316,134 +314,6 @@ class Archiver(DebugMixIn, TarMixIn, BenchmarkMixIn):
             return EXIT_WARNING
         return EXIT_SUCCESS
 
-    @with_repository(compatibility=(Manifest.Operation.CHECK,))
-    def do_change_passphrase(self, args, repository, manifest, key):
-        """Change repository key file passphrase"""
-        if not hasattr(key, "change_passphrase"):
-            print("This repository is not encrypted, cannot change the passphrase.")
-            return EXIT_ERROR
-        key.change_passphrase()
-        logger.info("Key updated")
-        if hasattr(key, "find_key"):
-            # print key location to make backing it up easier
-            logger.info("Key location: %s", key.find_key())
-        return EXIT_SUCCESS
-
-    @with_repository(exclusive=True, manifest=True, cache=True, compatibility=(Manifest.Operation.CHECK,))
-    def do_change_location(self, args, repository, manifest, key, cache):
-        """Change repository key location"""
-        if not hasattr(key, "change_passphrase"):
-            print("This repository is not encrypted, cannot change the key location.")
-            return EXIT_ERROR
-
-        if args.key_mode == "keyfile":
-            if isinstance(key, AESOCBRepoKey):
-                key_new = AESOCBKeyfileKey(repository)
-            elif isinstance(key, CHPORepoKey):
-                key_new = CHPOKeyfileKey(repository)
-            elif isinstance(key, Blake2AESOCBRepoKey):
-                key_new = Blake2AESOCBKeyfileKey(repository)
-            elif isinstance(key, Blake2CHPORepoKey):
-                key_new = Blake2CHPOKeyfileKey(repository)
-            else:
-                print("Change not needed or not supported.")
-                return EXIT_WARNING
-        if args.key_mode == "repokey":
-            if isinstance(key, AESOCBKeyfileKey):
-                key_new = AESOCBRepoKey(repository)
-            elif isinstance(key, CHPOKeyfileKey):
-                key_new = CHPORepoKey(repository)
-            elif isinstance(key, Blake2AESOCBKeyfileKey):
-                key_new = Blake2AESOCBRepoKey(repository)
-            elif isinstance(key, Blake2CHPOKeyfileKey):
-                key_new = Blake2CHPORepoKey(repository)
-            else:
-                print("Change not needed or not supported.")
-                return EXIT_WARNING
-
-        for name in (
-            "repository_id",
-            "enc_key",
-            "enc_hmac_key",
-            "id_key",
-            "chunk_seed",
-            "tam_required",
-            "sessionid",
-            "cipher",
-        ):
-            value = getattr(key, name)
-            setattr(key_new, name, value)
-
-        key_new.target = key_new.get_new_target(args)
-        # save with same passphrase and algorithm
-        key_new.save(key_new.target, key._passphrase, create=True, algorithm=key._encrypted_key_algorithm)
-
-        # rewrite the manifest with the new key, so that the key-type byte of the manifest changes
-        manifest.key = key_new
-        manifest.write()
-        repository.commit(compact=False)
-
-        # we need to rewrite cache config and security key-type info,
-        # so that the cached key-type will match the repo key-type.
-        cache.begin_txn()  # need to start a cache transaction, otherwise commit() does nothing.
-        cache.key = key_new
-        cache.commit()
-
-        loc = key_new.find_key() if hasattr(key_new, "find_key") else None
-        if args.keep:
-            logger.info(f"Key copied to {loc}")
-        else:
-            key.remove(key.target)  # remove key from current location
-            logger.info(f"Key moved to {loc}")
-
-        return EXIT_SUCCESS
-
-    @with_repository(exclusive=True, compatibility=(Manifest.Operation.CHECK,))
-    def do_change_algorithm(self, args, repository, manifest, key):
-        """Change repository key algorithm"""
-        if not hasattr(key, "change_passphrase"):
-            print("This repository is not encrypted, cannot change the algorithm.")
-            return EXIT_ERROR
-        key.save(key.target, key._passphrase, algorithm=KEY_ALGORITHMS[args.algorithm])
-        return EXIT_SUCCESS
-
-    @with_repository(lock=False, exclusive=False, manifest=False, cache=False)
-    def do_key_export(self, args, repository):
-        """Export the repository key for backup"""
-        manager = KeyManager(repository)
-        manager.load_keyblob()
-        if args.paper:
-            manager.export_paperkey(args.path)
-        else:
-            try:
-                if args.qr:
-                    manager.export_qr(args.path)
-                else:
-                    manager.export(args.path)
-            except IsADirectoryError:
-                self.print_error(f"'{args.path}' must be a file, not a directory")
-                return EXIT_ERROR
-        return EXIT_SUCCESS
-
-    @with_repository(lock=False, exclusive=False, manifest=False, cache=False)
-    def do_key_import(self, args, repository):
-        """Import the repository key from backup"""
-        manager = KeyManager(repository)
-        if args.paper:
-            if args.path:
-                self.print_error("with --paper import from file is not supported")
-                return EXIT_ERROR
-            manager.import_paperkey(args)
-        else:
-            if not args.path:
-                self.print_error("input file to import key from expected")
-                return EXIT_ERROR
-            if args.path != "-" and not os.path.exists(args.path):
-                self.print_error("input file does not exist: " + args.path)
-                return EXIT_ERROR
-            manager.import_keyfile(args)
-        return EXIT_SUCCESS
-
     @with_repository(fake="dry_run", exclusive=True, compatibility=(Manifest.Operation.WRITE,))
     def do_create(self, args, repository, manifest=None, key=None):
         """Create new archive"""
@@ -3683,173 +3553,7 @@ class Archiver(DebugMixIn, TarMixIn, BenchmarkMixIn):
             help="create the parent directories of the repository directory, if they are missing.",
         )
 
-        # borg key
-        subparser = subparsers.add_parser(
-            "key",
-            parents=[mid_common_parser],
-            add_help=False,
-            description="Manage a keyfile or repokey of a repository",
-            epilog="",
-            formatter_class=argparse.RawDescriptionHelpFormatter,
-            help="manage repository key",
-        )
-
-        key_parsers = subparser.add_subparsers(title="required arguments", metavar="<command>")
-        subparser.set_defaults(fallback_func=functools.partial(self.do_subcommand_help, subparser))
-
-        key_export_epilog = process_epilog(
-            """
-        If repository encryption is used, the repository is inaccessible
-        without the key. This command allows one to backup this essential key.
-        Note that the backup produced does not include the passphrase itself
-        (i.e. the exported key stays encrypted). In order to regain access to a
-        repository, one needs both the exported key and the original passphrase.
-
-        There are three backup formats. The normal backup format is suitable for
-        digital storage as a file. The ``--paper`` backup format is optimized
-        for printing and typing in while importing, with per line checks to
-        reduce problems with manual input. The ``--qr-html`` creates a printable
-        HTML template with a QR code and a copy of the ``--paper``-formatted key.
-
-        For repositories using keyfile encryption the key is saved locally
-        on the system that is capable of doing backups. To guard against loss
-        of this key, the key needs to be backed up independently of the main
-        data backup.
-
-        For repositories using the repokey encryption the key is saved in the
-        repository in the config file. A backup is thus not strictly needed,
-        but guards against the repository becoming inaccessible if the file
-        is damaged for some reason.
-
-        Examples::
-
-            borg key export /path/to/repo > encrypted-key-backup
-            borg key export --paper /path/to/repo > encrypted-key-backup.txt
-            borg key export --qr-html /path/to/repo > encrypted-key-backup.html
-            # Or pass the output file as an argument instead of redirecting stdout:
-            borg key export /path/to/repo encrypted-key-backup
-            borg key export --paper /path/to/repo encrypted-key-backup.txt
-            borg key export --qr-html /path/to/repo encrypted-key-backup.html
-
-
-        """
-        )
-        subparser = key_parsers.add_parser(
-            "export",
-            parents=[common_parser],
-            add_help=False,
-            description=self.do_key_export.__doc__,
-            epilog=key_export_epilog,
-            formatter_class=argparse.RawDescriptionHelpFormatter,
-            help="export repository key for backup",
-        )
-        subparser.set_defaults(func=self.do_key_export)
-        subparser.add_argument("path", metavar="PATH", nargs="?", type=str, help="where to store the backup")
-        subparser.add_argument(
-            "--paper",
-            dest="paper",
-            action="store_true",
-            help="Create an export suitable for printing and later type-in",
-        )
-        subparser.add_argument(
-            "--qr-html",
-            dest="qr",
-            action="store_true",
-            help="Create an html file suitable for printing and later type-in or qr scan",
-        )
-
-        key_import_epilog = process_epilog(
-            """
-        This command restores a key previously backed up with the export command.
-
-        If the ``--paper`` option is given, the import will be an interactive
-        process in which each line is checked for plausibility before
-        proceeding to the next line. For this format PATH must not be given.
-
-        For repositories using keyfile encryption, the key file which ``borg key
-        import`` writes to depends on several factors. If the ``BORG_KEY_FILE``
-        environment variable is set and non-empty, ``borg key import`` creates
-        or overwrites that file named by ``$BORG_KEY_FILE``. Otherwise, ``borg
-        key import`` searches in the ``$BORG_KEYS_DIR`` directory for a key file
-        associated with the repository. If a key file is found in
-        ``$BORG_KEYS_DIR``, ``borg key import`` overwrites it; otherwise, ``borg
-        key import`` creates a new key file in ``$BORG_KEYS_DIR``.
-        """
-        )
-        subparser = key_parsers.add_parser(
-            "import",
-            parents=[common_parser],
-            add_help=False,
-            description=self.do_key_import.__doc__,
-            epilog=key_import_epilog,
-            formatter_class=argparse.RawDescriptionHelpFormatter,
-            help="import repository key from backup",
-        )
-        subparser.set_defaults(func=self.do_key_import)
-        subparser.add_argument(
-            "path", metavar="PATH", nargs="?", type=str, help="path to the backup ('-' to read from stdin)"
-        )
-        subparser.add_argument(
-            "--paper",
-            dest="paper",
-            action="store_true",
-            help="interactively import from a backup done with ``--paper``",
-        )
-
-        change_passphrase_epilog = process_epilog(
-            """
-        The key files used for repository encryption are optionally passphrase
-        protected. This command can be used to change this passphrase.
-
-        Please note that this command only changes the passphrase, but not any
-        secret protected by it (like e.g. encryption/MAC keys or chunker seed).
-        Thus, changing the passphrase after passphrase and borg key got compromised
-        does not protect future (nor past) backups to the same repository.
-        """
-        )
-        subparser = key_parsers.add_parser(
-            "change-passphrase",
-            parents=[common_parser],
-            add_help=False,
-            description=self.do_change_passphrase.__doc__,
-            epilog=change_passphrase_epilog,
-            formatter_class=argparse.RawDescriptionHelpFormatter,
-            help="change repository passphrase",
-        )
-        subparser.set_defaults(func=self.do_change_passphrase)
-
-        change_location_epilog = process_epilog(
-            """
-        Change the location of a borg key. The key can be stored at different locations:
-
-        - keyfile: locally, usually in the home directory
-        - repokey: inside the repo (in the repo config)
-
-        Please note:
-
-        This command does NOT change the crypto algorithms, just the key location,
-        thus you must ONLY give the key location (keyfile or repokey).
-        """
-        )
-        subparser = key_parsers.add_parser(
-            "change-location",
-            parents=[common_parser],
-            add_help=False,
-            description=self.do_change_location.__doc__,
-            epilog=change_location_epilog,
-            formatter_class=argparse.RawDescriptionHelpFormatter,
-            help="change key location",
-        )
-        subparser.set_defaults(func=self.do_change_location)
-        subparser.add_argument(
-            "key_mode", metavar="KEY_LOCATION", choices=("repokey", "keyfile"), help="select key location"
-        )
-        subparser.add_argument(
-            "--keep",
-            dest="keep",
-            action="store_true",
-            help="keep the key also at the current location (default: remove it)",
-        )
+        self.build_parser_keys(subparsers, common_parser, mid_common_parser)
 
         # borg list
         list_epilog = (
diff --git a/src/borg/archiver/keys.py b/src/borg/archiver/keys.py
new file mode 100644
index 000000000..f4c09b6be
--- /dev/null
+++ b/src/borg/archiver/keys.py
@@ -0,0 +1,316 @@
+import argparse
+import functools
+import os
+
+from ..constants import *  # NOQA
+from ..crypto.key import AESOCBRepoKey, CHPORepoKey, Blake2AESOCBRepoKey, Blake2CHPORepoKey
+from ..crypto.key import AESOCBKeyfileKey, CHPOKeyfileKey, Blake2AESOCBKeyfileKey, Blake2CHPOKeyfileKey
+from ..crypto.keymanager import KeyManager
+from ..helpers import Manifest
+
+from .common import with_repository
+
+from ..logger import create_logger
+
+logger = create_logger(__name__)
+
+
+class KeysMixIn:
+    @with_repository(compatibility=(Manifest.Operation.CHECK,))
+    def do_change_passphrase(self, args, repository, manifest, key):
+        """Change repository key file passphrase"""
+        if not hasattr(key, "change_passphrase"):
+            print("This repository is not encrypted, cannot change the passphrase.")
+            return EXIT_ERROR
+        key.change_passphrase()
+        logger.info("Key updated")
+        if hasattr(key, "find_key"):
+            # print key location to make backing it up easier
+            logger.info("Key location: %s", key.find_key())
+        return EXIT_SUCCESS
+
+    @with_repository(exclusive=True, manifest=True, cache=True, compatibility=(Manifest.Operation.CHECK,))
+    def do_change_location(self, args, repository, manifest, key, cache):
+        """Change repository key location"""
+        if not hasattr(key, "change_passphrase"):
+            print("This repository is not encrypted, cannot change the key location.")
+            return EXIT_ERROR
+
+        if args.key_mode == "keyfile":
+            if isinstance(key, AESOCBRepoKey):
+                key_new = AESOCBKeyfileKey(repository)
+            elif isinstance(key, CHPORepoKey):
+                key_new = CHPOKeyfileKey(repository)
+            elif isinstance(key, Blake2AESOCBRepoKey):
+                key_new = Blake2AESOCBKeyfileKey(repository)
+            elif isinstance(key, Blake2CHPORepoKey):
+                key_new = Blake2CHPOKeyfileKey(repository)
+            else:
+                print("Change not needed or not supported.")
+                return EXIT_WARNING
+        if args.key_mode == "repokey":
+            if isinstance(key, AESOCBKeyfileKey):
+                key_new = AESOCBRepoKey(repository)
+            elif isinstance(key, CHPOKeyfileKey):
+                key_new = CHPORepoKey(repository)
+            elif isinstance(key, Blake2AESOCBKeyfileKey):
+                key_new = Blake2AESOCBRepoKey(repository)
+            elif isinstance(key, Blake2CHPOKeyfileKey):
+                key_new = Blake2CHPORepoKey(repository)
+            else:
+                print("Change not needed or not supported.")
+                return EXIT_WARNING
+
+        for name in (
+            "repository_id",
+            "enc_key",
+            "enc_hmac_key",
+            "id_key",
+            "chunk_seed",
+            "tam_required",
+            "sessionid",
+            "cipher",
+        ):
+            value = getattr(key, name)
+            setattr(key_new, name, value)
+
+        key_new.target = key_new.get_new_target(args)
+        # save with same passphrase and algorithm
+        key_new.save(key_new.target, key._passphrase, create=True, algorithm=key._encrypted_key_algorithm)
+
+        # rewrite the manifest with the new key, so that the key-type byte of the manifest changes
+        manifest.key = key_new
+        manifest.write()
+        repository.commit(compact=False)
+
+        # we need to rewrite cache config and security key-type info,
+        # so that the cached key-type will match the repo key-type.
+        cache.begin_txn()  # need to start a cache transaction, otherwise commit() does nothing.
+        cache.key = key_new
+        cache.commit()
+
+        loc = key_new.find_key() if hasattr(key_new, "find_key") else None
+        if args.keep:
+            logger.info(f"Key copied to {loc}")
+        else:
+            key.remove(key.target)  # remove key from current location
+            logger.info(f"Key moved to {loc}")
+
+        return EXIT_SUCCESS
+
+    @with_repository(exclusive=True, compatibility=(Manifest.Operation.CHECK,))
+    def do_change_algorithm(self, args, repository, manifest, key):
+        """Change repository key algorithm"""
+        if not hasattr(key, "change_passphrase"):
+            print("This repository is not encrypted, cannot change the algorithm.")
+            return EXIT_ERROR
+        key.save(key.target, key._passphrase, algorithm=KEY_ALGORITHMS[args.algorithm])
+        return EXIT_SUCCESS
+
+    @with_repository(lock=False, exclusive=False, manifest=False, cache=False)
+    def do_key_export(self, args, repository):
+        """Export the repository key for backup"""
+        manager = KeyManager(repository)
+        manager.load_keyblob()
+        if args.paper:
+            manager.export_paperkey(args.path)
+        else:
+            try:
+                if args.qr:
+                    manager.export_qr(args.path)
+                else:
+                    manager.export(args.path)
+            except IsADirectoryError:
+                self.print_error(f"'{args.path}' must be a file, not a directory")
+                return EXIT_ERROR
+        return EXIT_SUCCESS
+
+    @with_repository(lock=False, exclusive=False, manifest=False, cache=False)
+    def do_key_import(self, args, repository):
+        """Import the repository key from backup"""
+        manager = KeyManager(repository)
+        if args.paper:
+            if args.path:
+                self.print_error("with --paper import from file is not supported")
+                return EXIT_ERROR
+            manager.import_paperkey(args)
+        else:
+            if not args.path:
+                self.print_error("input file to import key from expected")
+                return EXIT_ERROR
+            if args.path != "-" and not os.path.exists(args.path):
+                self.print_error("input file does not exist: " + args.path)
+                return EXIT_ERROR
+            manager.import_keyfile(args)
+        return EXIT_SUCCESS
+
+    def build_parser_keys(self, subparsers, common_parser, mid_common_parser):
+
+        from .common import process_epilog
+
+        subparser = subparsers.add_parser(
+            "key",
+            parents=[mid_common_parser],
+            add_help=False,
+            description="Manage a keyfile or repokey of a repository",
+            epilog="",
+            formatter_class=argparse.RawDescriptionHelpFormatter,
+            help="manage repository key",
+        )
+
+        key_parsers = subparser.add_subparsers(title="required arguments", metavar="<command>")
+        subparser.set_defaults(fallback_func=functools.partial(self.do_subcommand_help, subparser))
+
+        key_export_epilog = process_epilog(
+            """
+        If repository encryption is used, the repository is inaccessible
+        without the key. This command allows one to backup this essential key.
+        Note that the backup produced does not include the passphrase itself
+        (i.e. the exported key stays encrypted). In order to regain access to a
+        repository, one needs both the exported key and the original passphrase.
+
+        There are three backup formats. The normal backup format is suitable for
+        digital storage as a file. The ``--paper`` backup format is optimized
+        for printing and typing in while importing, with per line checks to
+        reduce problems with manual input. The ``--qr-html`` creates a printable
+        HTML template with a QR code and a copy of the ``--paper``-formatted key.
+
+        For repositories using keyfile encryption the key is saved locally
+        on the system that is capable of doing backups. To guard against loss
+        of this key, the key needs to be backed up independently of the main
+        data backup.
+
+        For repositories using the repokey encryption the key is saved in the
+        repository in the config file. A backup is thus not strictly needed,
+        but guards against the repository becoming inaccessible if the file
+        is damaged for some reason.
+
+        Examples::
+
+            borg key export /path/to/repo > encrypted-key-backup
+            borg key export --paper /path/to/repo > encrypted-key-backup.txt
+            borg key export --qr-html /path/to/repo > encrypted-key-backup.html
+            # Or pass the output file as an argument instead of redirecting stdout:
+            borg key export /path/to/repo encrypted-key-backup
+            borg key export --paper /path/to/repo encrypted-key-backup.txt
+            borg key export --qr-html /path/to/repo encrypted-key-backup.html
+
+
+        """
+        )
+        subparser = key_parsers.add_parser(
+            "export",
+            parents=[common_parser],
+            add_help=False,
+            description=self.do_key_export.__doc__,
+            epilog=key_export_epilog,
+            formatter_class=argparse.RawDescriptionHelpFormatter,
+            help="export repository key for backup",
+        )
+        subparser.set_defaults(func=self.do_key_export)
+        subparser.add_argument("path", metavar="PATH", nargs="?", type=str, help="where to store the backup")
+        subparser.add_argument(
+            "--paper",
+            dest="paper",
+            action="store_true",
+            help="Create an export suitable for printing and later type-in",
+        )
+        subparser.add_argument(
+            "--qr-html",
+            dest="qr",
+            action="store_true",
+            help="Create an html file suitable for printing and later type-in or qr scan",
+        )
+
+        key_import_epilog = process_epilog(
+            """
+        This command restores a key previously backed up with the export command.
+
+        If the ``--paper`` option is given, the import will be an interactive
+        process in which each line is checked for plausibility before
+        proceeding to the next line. For this format PATH must not be given.
+
+        For repositories using keyfile encryption, the key file which ``borg key
+        import`` writes to depends on several factors. If the ``BORG_KEY_FILE``
+        environment variable is set and non-empty, ``borg key import`` creates
+        or overwrites that file named by ``$BORG_KEY_FILE``. Otherwise, ``borg
+        key import`` searches in the ``$BORG_KEYS_DIR`` directory for a key file
+        associated with the repository. If a key file is found in
+        ``$BORG_KEYS_DIR``, ``borg key import`` overwrites it; otherwise, ``borg
+        key import`` creates a new key file in ``$BORG_KEYS_DIR``.
+        """
+        )
+        subparser = key_parsers.add_parser(
+            "import",
+            parents=[common_parser],
+            add_help=False,
+            description=self.do_key_import.__doc__,
+            epilog=key_import_epilog,
+            formatter_class=argparse.RawDescriptionHelpFormatter,
+            help="import repository key from backup",
+        )
+        subparser.set_defaults(func=self.do_key_import)
+        subparser.add_argument(
+            "path", metavar="PATH", nargs="?", type=str, help="path to the backup ('-' to read from stdin)"
+        )
+        subparser.add_argument(
+            "--paper",
+            dest="paper",
+            action="store_true",
+            help="interactively import from a backup done with ``--paper``",
+        )
+
+        change_passphrase_epilog = process_epilog(
+            """
+        The key files used for repository encryption are optionally passphrase
+        protected. This command can be used to change this passphrase.
+
+        Please note that this command only changes the passphrase, but not any
+        secret protected by it (like e.g. encryption/MAC keys or chunker seed).
+        Thus, changing the passphrase after passphrase and borg key got compromised
+        does not protect future (nor past) backups to the same repository.
+        """
+        )
+        subparser = key_parsers.add_parser(
+            "change-passphrase",
+            parents=[common_parser],
+            add_help=False,
+            description=self.do_change_passphrase.__doc__,
+            epilog=change_passphrase_epilog,
+            formatter_class=argparse.RawDescriptionHelpFormatter,
+            help="change repository passphrase",
+        )
+        subparser.set_defaults(func=self.do_change_passphrase)
+
+        change_location_epilog = process_epilog(
+            """
+        Change the location of a borg key. The key can be stored at different locations:
+
+        - keyfile: locally, usually in the home directory
+        - repokey: inside the repo (in the repo config)
+
+        Please note:
+
+        This command does NOT change the crypto algorithms, just the key location,
+        thus you must ONLY give the key location (keyfile or repokey).
+        """
+        )
+        subparser = key_parsers.add_parser(
+            "change-location",
+            parents=[common_parser],
+            add_help=False,
+            description=self.do_change_location.__doc__,
+            epilog=change_location_epilog,
+            formatter_class=argparse.RawDescriptionHelpFormatter,
+            help="change key location",
+        )
+        subparser.set_defaults(func=self.do_change_location)
+        subparser.add_argument(
+            "key_mode", metavar="KEY_LOCATION", choices=("repokey", "keyfile"), help="select key location"
+        )
+        subparser.add_argument(
+            "--keep",
+            dest="keep",
+            action="store_true",
+            help="keep the key also at the current location (default: remove it)",
+        )

From f906d9d2466dcffcc0fb6eb2d524d2de9ab4162d Mon Sep 17 00:00:00 2001
From: Thomas Waldmann <tw@waldmann-edv.de>
Date: Fri, 8 Jul 2022 03:35:46 +0200
Subject: [PATCH 122/160] move locking commands to archiver.locks

---
 src/borg/archiver/__init__.py |  92 +-----------------------------
 src/borg/archiver/locks.py    | 103 ++++++++++++++++++++++++++++++++++
 2 files changed, 106 insertions(+), 89 deletions(-)
 create mode 100644 src/borg/archiver/locks.py

diff --git a/src/borg/archiver/__init__.py b/src/borg/archiver/__init__.py
index 1cd1b28c4..6b661930b 100644
--- a/src/borg/archiver/__init__.py
+++ b/src/borg/archiver/__init__.py
@@ -58,7 +58,6 @@ try:
     from ..helpers import ErrorIgnoringTextIOWrapper
     from ..helpers import ProgressIndicatorPercent
     from ..helpers import basic_json_data, json_print
-    from ..helpers import prepare_subprocess_env
     from ..helpers import umount
     from ..helpers import flags_root, flags_dir, flags_special_follow, flags_special
     from ..helpers import msgpack
@@ -107,10 +106,11 @@ def get_func(args):
 from .benchmarks import BenchmarkMixIn
 from .debug import DebugMixIn
 from .keys import KeysMixIn
+from .locks import LocksMixIn
 from .tar import TarMixIn
 
 
-class Archiver(DebugMixIn, TarMixIn, BenchmarkMixIn, KeysMixIn):
+class Archiver(DebugMixIn, TarMixIn, BenchmarkMixIn, KeysMixIn, LocksMixIn):
     def __init__(self, lock_wait=None, prog=None):
         self.exit_code = EXIT_SUCCESS
         self.lock_wait = lock_wait
@@ -1376,36 +1376,6 @@ class Archiver(DebugMixIn, TarMixIn, BenchmarkMixIn, KeysMixIn):
             cache.commit()
         return self.exit_code
 
-    @with_repository(manifest=False, exclusive=True)
-    def do_with_lock(self, args, repository):
-        """run a user specified command with the repository lock held"""
-        # for a new server, this will immediately take an exclusive lock.
-        # to support old servers, that do not have "exclusive" arg in open()
-        # RPC API, we also do it the old way:
-        # re-write manifest to start a repository transaction - this causes a
-        # lock upgrade to exclusive for remote (and also for local) repositories.
-        # by using manifest=False in the decorator, we avoid having to require
-        # the encryption key (and can operate just with encrypted data).
-        data = repository.get(Manifest.MANIFEST_ID)
-        repository.put(Manifest.MANIFEST_ID, data)
-        # usually, a 0 byte (open for writing) segment file would be visible in the filesystem here.
-        # we write and close this file, to rather have a valid segment file on disk, before invoking the subprocess.
-        # we can only do this for local repositories (with .io), though:
-        if hasattr(repository, "io"):
-            repository.io.close_segment()
-        env = prepare_subprocess_env(system=True)
-        try:
-            # we exit with the return code we get from the subprocess
-            return subprocess.call([args.command] + args.args, env=env)
-        finally:
-            # we need to commit the "no change" operation we did to the manifest
-            # because it created a new segment file in the repository. if we would
-            # roll back, the same file would be later used otherwise (for other content).
-            # that would be bad if somebody uses rsync with ignore-existing (or
-            # any other mechanism relying on existing segment data not changing).
-            # see issue #1867.
-            repository.commit(compact=False)
-
     @with_repository(manifest=False, exclusive=True)
     def do_compact(self, args, repository):
         """compact segment files in the repository"""
@@ -1547,13 +1517,6 @@ class Archiver(DebugMixIn, TarMixIn, BenchmarkMixIn, KeysMixIn):
             if args.cache:
                 cache.close()
 
-    @with_repository(lock=False, manifest=False)
-    def do_break_lock(self, args, repository):
-        """Break the repository lock (e.g. in case it was left by a dead borg."""
-        repository.break_lock()
-        Cache.break_lock(repository)
-        return self.exit_code
-
     helptext = collections.OrderedDict()
     helptext["patterns"] = textwrap.dedent(
         """
@@ -2424,25 +2387,7 @@ class Archiver(DebugMixIn, TarMixIn, BenchmarkMixIn, KeysMixIn):
         subparsers = parser.add_subparsers(title="required arguments", metavar="<command>")
 
         self.build_parser_benchmarks(subparsers, common_parser, mid_common_parser)
-
-        # borg break-lock
-        break_lock_epilog = process_epilog(
-            """
-        This command breaks the repository and cache locks.
-        Please use carefully and only while no borg process (on any machine) is
-        trying to access the Cache or the Repository.
-        """
-        )
-        subparser = subparsers.add_parser(
-            "break-lock",
-            parents=[common_parser],
-            add_help=False,
-            description=self.do_break_lock.__doc__,
-            epilog=break_lock_epilog,
-            formatter_class=argparse.RawDescriptionHelpFormatter,
-            help="break repository and cache locks",
-        )
-        subparser.set_defaults(func=self.do_break_lock)
+        self.build_parser_locks(subparsers, common_parser, mid_common_parser)
 
         # borg check
         check_epilog = process_epilog(
@@ -4107,37 +4052,6 @@ class Archiver(DebugMixIn, TarMixIn, BenchmarkMixIn, KeysMixIn):
             "mountpoint", metavar="MOUNTPOINT", type=str, help="mountpoint of the filesystem to umount"
         )
 
-        # borg with-lock
-        with_lock_epilog = process_epilog(
-            """
-        This command runs a user-specified command while the repository lock is held.
-
-        It will first try to acquire the lock (make sure that no other operation is
-        running in the repo), then execute the given command as a subprocess and wait
-        for its termination, release the lock and return the user command's return
-        code as borg's return code.
-
-        .. note::
-
-            If you copy a repository with the lock held, the lock will be present in
-            the copy. Thus, before using borg on the copy from a different host,
-            you need to use "borg break-lock" on the copied repository, because
-            Borg is cautious and does not automatically remove stale locks made by a different host.
-        """
-        )
-        subparser = subparsers.add_parser(
-            "with-lock",
-            parents=[common_parser],
-            add_help=False,
-            description=self.do_with_lock.__doc__,
-            epilog=with_lock_epilog,
-            formatter_class=argparse.RawDescriptionHelpFormatter,
-            help="run user command with lock held",
-        )
-        subparser.set_defaults(func=self.do_with_lock)
-        subparser.add_argument("command", metavar="COMMAND", help="command to run")
-        subparser.add_argument("args", metavar="ARGS", nargs=argparse.REMAINDER, help="command arguments")
-
         self.build_parser_tar(subparsers, common_parser, mid_common_parser)
 
         return parser
diff --git a/src/borg/archiver/locks.py b/src/borg/archiver/locks.py
new file mode 100644
index 000000000..657afe985
--- /dev/null
+++ b/src/borg/archiver/locks.py
@@ -0,0 +1,103 @@
+import argparse
+import subprocess
+
+from .common import with_repository
+from ..cache import Cache
+from ..constants import *  # NOQA
+from ..helpers import Manifest
+from ..helpers import prepare_subprocess_env
+
+from ..logger import create_logger
+
+logger = create_logger()
+
+
+class LocksMixIn:
+    @with_repository(manifest=False, exclusive=True)
+    def do_with_lock(self, args, repository):
+        """run a user specified command with the repository lock held"""
+        # for a new server, this will immediately take an exclusive lock.
+        # to support old servers, that do not have "exclusive" arg in open()
+        # RPC API, we also do it the old way:
+        # re-write manifest to start a repository transaction - this causes a
+        # lock upgrade to exclusive for remote (and also for local) repositories.
+        # by using manifest=False in the decorator, we avoid having to require
+        # the encryption key (and can operate just with encrypted data).
+        data = repository.get(Manifest.MANIFEST_ID)
+        repository.put(Manifest.MANIFEST_ID, data)
+        # usually, a 0 byte (open for writing) segment file would be visible in the filesystem here.
+        # we write and close this file, to rather have a valid segment file on disk, before invoking the subprocess.
+        # we can only do this for local repositories (with .io), though:
+        if hasattr(repository, "io"):
+            repository.io.close_segment()
+        env = prepare_subprocess_env(system=True)
+        try:
+            # we exit with the return code we get from the subprocess
+            return subprocess.call([args.command] + args.args, env=env)
+        finally:
+            # we need to commit the "no change" operation we did to the manifest
+            # because it created a new segment file in the repository. if we would
+            # roll back, the same file would be later used otherwise (for other content).
+            # that would be bad if somebody uses rsync with ignore-existing (or
+            # any other mechanism relying on existing segment data not changing).
+            # see issue #1867.
+            repository.commit(compact=False)
+
+    @with_repository(lock=False, manifest=False)
+    def do_break_lock(self, args, repository):
+        """Break the repository lock (e.g. in case it was left by a dead borg."""
+        repository.break_lock()
+        Cache.break_lock(repository)
+        return self.exit_code
+
+    def build_parser_locks(self, subparsers, common_parser, mid_common_parser):
+
+        from .common import process_epilog
+
+        break_lock_epilog = process_epilog(
+            """
+        This command breaks the repository and cache locks.
+        Please use carefully and only while no borg process (on any machine) is
+        trying to access the Cache or the Repository.
+        """
+        )
+        subparser = subparsers.add_parser(
+            "break-lock",
+            parents=[common_parser],
+            add_help=False,
+            description=self.do_break_lock.__doc__,
+            epilog=break_lock_epilog,
+            formatter_class=argparse.RawDescriptionHelpFormatter,
+            help="break repository and cache locks",
+        )
+        subparser.set_defaults(func=self.do_break_lock)
+
+        with_lock_epilog = process_epilog(
+            """
+        This command runs a user-specified command while the repository lock is held.
+
+        It will first try to acquire the lock (make sure that no other operation is
+        running in the repo), then execute the given command as a subprocess and wait
+        for its termination, release the lock and return the user command's return
+        code as borg's return code.
+
+        .. note::
+
+            If you copy a repository with the lock held, the lock will be present in
+            the copy. Thus, before using borg on the copy from a different host,
+            you need to use "borg break-lock" on the copied repository, because
+            Borg is cautious and does not automatically remove stale locks made by a different host.
+        """
+        )
+        subparser = subparsers.add_parser(
+            "with-lock",
+            parents=[common_parser],
+            add_help=False,
+            description=self.do_with_lock.__doc__,
+            epilog=with_lock_epilog,
+            formatter_class=argparse.RawDescriptionHelpFormatter,
+            help="run user command with lock held",
+        )
+        subparser.set_defaults(func=self.do_with_lock)
+        subparser.add_argument("command", metavar="COMMAND", help="command to run")
+        subparser.add_argument("args", metavar="ARGS", nargs=argparse.REMAINDER, help="command arguments")

From 6d60976c516e359f5f14eb795709d88c7487b404 Mon Sep 17 00:00:00 2001
From: Thomas Waldmann <tw@waldmann-edv.de>
Date: Fri, 8 Jul 2022 03:50:43 +0200
Subject: [PATCH 123/160] move help commands to archiver.help

---
 setup.cfg                     |   1 +
 src/borg/archiver/__init__.py | 428 +--------------------------------
 src/borg/archiver/help.py     | 430 ++++++++++++++++++++++++++++++++++
 3 files changed, 434 insertions(+), 425 deletions(-)
 create mode 100644 src/borg/archiver/help.py

diff --git a/setup.cfg b/setup.cfg
index 61b61074f..3db6c8a97 100644
--- a/setup.cfg
+++ b/setup.cfg
@@ -120,6 +120,7 @@ per_file_ignores =
     src/borg/archiver/benchmarks.py:F405
     src/borg/archiver/common.py:E501,F405
     src/borg/archiver/debug.py:F405
+    src/borg/archiver/help.py:E501,F405
     src/borg/archiver/keys.py:F405
     src/borg/archiver/tar.py:F405
     src/borg/cache.py:E127,E128,E402,E501,E722,W504
diff --git a/src/borg/archiver/__init__.py b/src/borg/archiver/__init__.py
index 6b661930b..bbea5b7e0 100644
--- a/src/borg/archiver/__init__.py
+++ b/src/borg/archiver/__init__.py
@@ -5,7 +5,6 @@ import traceback
 
 try:
     import argparse
-    import collections
     import configparser
     import faulthandler
     import functools
@@ -63,7 +62,6 @@ try:
     from ..helpers import msgpack
     from ..helpers import sig_int
     from ..helpers import iter_separated
-    from ..nanorst import rst_to_terminal
     from ..patterns import PatternMatcher
     from ..platform import get_flags
     from ..platform import uid2user, gid2group
@@ -105,12 +103,13 @@ def get_func(args):
 
 from .benchmarks import BenchmarkMixIn
 from .debug import DebugMixIn
+from .help import HelpMixIn
 from .keys import KeysMixIn
 from .locks import LocksMixIn
 from .tar import TarMixIn
 
 
-class Archiver(DebugMixIn, TarMixIn, BenchmarkMixIn, KeysMixIn, LocksMixIn):
+class Archiver(DebugMixIn, TarMixIn, BenchmarkMixIn, KeysMixIn, LocksMixIn, HelpMixIn):
     def __init__(self, lock_wait=None, prog=None):
         self.exit_code = EXIT_SUCCESS
         self.lock_wait = lock_wait
@@ -1517,421 +1516,6 @@ class Archiver(DebugMixIn, TarMixIn, BenchmarkMixIn, KeysMixIn, LocksMixIn):
             if args.cache:
                 cache.close()
 
-    helptext = collections.OrderedDict()
-    helptext["patterns"] = textwrap.dedent(
-        """
-        When specifying one or more file paths in a Borg command that supports
-        patterns for the respective option or argument, you can apply the
-        patterns described here to include only desired files and/or exclude
-        unwanted ones. Patterns can be used
-
-        - for ``--exclude`` option,
-        - in the file given with ``--exclude-from`` option,
-        - for ``--pattern`` option,
-        - in the file given with ``--patterns-from`` option and
-        - for ``PATH`` arguments that explicitly support them.
-
-        Borg always stores all file paths normalized and relative to the
-        current recursion root. The recursion root is also named ``PATH`` in
-        Borg commands like `borg create` that do a file discovery, so do not
-        confuse the root with the ``PATH`` argument of e.g. `borg extract`.
-
-        Starting with Borg 1.2, paths that are matched against patterns always
-        appear relative. If you give ``/absolute/`` as root, the paths going
-        into the matcher will look relative like ``absolute/.../file.ext``.
-        If you give ``../some/path`` as root, the paths will look like
-        ``some/path/.../file.ext``.
-
-        File patterns support five different styles. If followed by a colon ':',
-        the first two characters of a pattern are used as a style selector.
-        Explicit style selection is necessary if a non-default style is desired
-        or when the desired pattern starts with two alphanumeric characters
-        followed by a colon (i.e. ``aa:something/*``).
-
-        `Fnmatch <https://docs.python.org/3/library/fnmatch.html>`_, selector ``fm:``
-            This is the default style for ``--exclude`` and ``--exclude-from``.
-            These patterns use a variant of shell pattern syntax, with '\\*' matching
-            any number of characters, '?' matching any single character, '[...]'
-            matching any single character specified, including ranges, and '[!...]'
-            matching any character not specified. For the purpose of these patterns,
-            the path separator (backslash for Windows and '/' on other systems) is not
-            treated specially. Wrap meta-characters in brackets for a literal
-            match (i.e. ``[?]`` to match the literal character '?'). For a path
-            to match a pattern, the full path must match, or it must match
-            from the start of the full path to just before a path separator. Except
-            for the root path, paths will never end in the path separator when
-            matching is attempted.  Thus, if a given pattern ends in a path
-            separator, a '\\*' is appended before matching is attempted. A leading
-            path separator is always removed.
-
-        Shell-style patterns, selector ``sh:``
-            This is the default style for ``--pattern`` and ``--patterns-from``.
-            Like fnmatch patterns these are similar to shell patterns. The difference
-            is that the pattern may include ``**/`` for matching zero or more directory
-            levels, ``*`` for matching zero or more arbitrary characters with the
-            exception of any path separator. A leading path separator is always removed.
-
-        `Regular expressions <https://docs.python.org/3/library/re.html>`_, selector ``re:``
-            Unlike shell patterns, regular expressions are not required to match the full
-            path and any substring match is sufficient. It is strongly recommended to
-            anchor patterns to the start ('^'), to the end ('$') or both. Path
-            separators (backslash for Windows and '/' on other systems) in paths are
-            always normalized to a forward slash '/' before applying a pattern.
-
-        Path prefix, selector ``pp:``
-            This pattern style is useful to match whole sub-directories. The pattern
-            ``pp:root/somedir`` matches ``root/somedir`` and everything therein.
-            A leading path separator is always removed.
-
-        Path full-match, selector ``pf:``
-            This pattern style is (only) useful to match full paths.
-            This is kind of a pseudo pattern as it can not have any variable or
-            unspecified parts - the full path must be given. ``pf:root/file.ext``
-            matches ``root/file.ext`` only. A leading path separator is always
-            removed.
-
-            Implementation note: this is implemented via very time-efficient O(1)
-            hashtable lookups (this means you can have huge amounts of such patterns
-            without impacting performance much).
-            Due to that, this kind of pattern does not respect any context or order.
-            If you use such a pattern to include a file, it will always be included
-            (if the directory recursion encounters it).
-            Other include/exclude patterns that would normally match will be ignored.
-            Same logic applies for exclude.
-
-        .. note::
-
-            ``re:``, ``sh:`` and ``fm:`` patterns are all implemented on top of
-            the Python SRE engine. It is very easy to formulate patterns for each
-            of these types which requires an inordinate amount of time to match
-            paths. If untrusted users are able to supply patterns, ensure they
-            cannot supply ``re:`` patterns. Further, ensure that ``sh:`` and
-            ``fm:`` patterns only contain a handful of wildcards at most.
-
-        Exclusions can be passed via the command line option ``--exclude``. When used
-        from within a shell, the patterns should be quoted to protect them from
-        expansion.
-
-        The ``--exclude-from`` option permits loading exclusion patterns from a text
-        file with one pattern per line. Lines empty or starting with the hash sign
-        '#' after removing whitespace on both ends are ignored. The optional style
-        selector prefix is also supported for patterns loaded from a file. Due to
-        whitespace removal, paths with whitespace at the beginning or end can only be
-        excluded using regular expressions.
-
-        To test your exclusion patterns without performing an actual backup you can
-        run ``borg create --list --dry-run ...``.
-
-        Examples::
-
-            # Exclude '/home/user/file.o' but not '/home/user/file.odt':
-            $ borg create -e '*.o' archive /
-
-            # Exclude '/home/user/junk' and '/home/user/subdir/junk' but
-            # not '/home/user/importantjunk' or '/etc/junk':
-            $ borg create -e 'home/*/junk' archive /
-
-            # Exclude the contents of '/home/user/cache' but not the directory itself:
-            $ borg create -e home/user/cache/ archive /
-
-            # The file '/home/user/cache/important' is *not* backed up:
-            $ borg create -e home/user/cache/ archive / /home/user/cache/important
-
-            # The contents of directories in '/home' are not backed up when their name
-            # ends in '.tmp'
-            $ borg create --exclude 're:^home/[^/]+\\.tmp/' archive /
-
-            # Load exclusions from file
-            $ cat >exclude.txt <<EOF
-            # Comment line
-            home/*/junk
-            *.tmp
-            fm:aa:something/*
-            re:^home/[^/]+\\.tmp/
-            sh:home/*/.thumbnails
-            # Example with spaces, no need to escape as it is processed by borg
-            some file with spaces.txt
-            EOF
-            $ borg create --exclude-from exclude.txt archive /
-
-        A more general and easier to use way to define filename matching patterns
-        exists with the ``--pattern`` and ``--patterns-from`` options. Using
-        these, you may specify the backup roots, default pattern styles and
-        patterns for inclusion and exclusion.
-
-        Root path prefix ``R``
-            A recursion root path starts with the prefix ``R``, followed by a path
-            (a plain path, not a file pattern). Use this prefix to have the root
-            paths in the patterns file rather than as command line arguments.
-
-        Pattern style prefix ``P``
-            To change the default pattern style, use the ``P`` prefix, followed by
-            the pattern style abbreviation (``fm``, ``pf``, ``pp``, ``re``, ``sh``).
-            All patterns following this line will use this style until another style
-            is specified.
-
-        Exclude pattern prefix ``-``
-            Use the prefix ``-``, followed by a pattern, to define an exclusion.
-            This has the same effect as the ``--exclude`` option.
-
-        Exclude no-recurse pattern prefix ``!``
-            Use the prefix ``!``, followed by a pattern, to define an exclusion
-            that does not recurse into subdirectories. This saves time, but
-            prevents include patterns to match any files in subdirectories.
-
-        Include pattern prefix ``+``
-            Use the prefix ``+``, followed by a pattern, to define inclusions.
-            This is useful to include paths that are covered in an exclude
-            pattern and would otherwise not be backed up.
-
-        The first matching pattern is used, so if an include pattern matches
-        before an exclude pattern, the file is backed up. Note that a no-recurse
-        exclude stops examination of subdirectories so that potential includes
-        will not match - use normal exludes for such use cases.
-
-        **Tip: You can easily test your patterns with --dry-run and  --list**::
-
-            $ borg create --dry-run --list --patterns-from patterns.txt archive
-
-        This will list the considered files one per line, prefixed with a
-        character that indicates the action (e.g. 'x' for excluding, see
-        **Item flags** in `borg create` usage docs).
-
-        .. note::
-
-            It's possible that a sub-directory/file is matched while parent
-            directories are not. In that case, parent directories are not backed
-            up and thus their user, group, permission, etc. cannot be restored.
-
-        Patterns (``--pattern``) and excludes (``--exclude``) from the command line are
-        considered first (in the order of appearance). Then patterns from ``--patterns-from``
-        are added. Exclusion patterns from ``--exclude-from`` files are appended last.
-
-        Examples::
-
-            # backup pics, but not the ones from 2018, except the good ones:
-            # note: using = is essential to avoid cmdline argument parsing issues.
-            borg create --pattern=+pics/2018/good --pattern=-pics/2018 archive pics
-
-            # backup only JPG/JPEG files (case insensitive) in all home directories:
-            borg create --pattern '+ re:\\.jpe?g(?i)$' archive /home
-
-            # backup homes, but exclude big downloads (like .ISO files) or hidden files:
-            borg create --exclude 're:\\.iso(?i)$' --exclude 'sh:home/**/.*' archive /home
-
-            # use a file with patterns (recursion root '/' via command line):
-            borg create --patterns-from patterns.lst archive /
-
-        The patterns.lst file could look like that::
-
-            # "sh:" pattern style is the default
-            # exclude caches
-            - home/*/.cache
-            # include susans home
-            + home/susan
-            # also back up this exact file
-            + pf:home/bobby/specialfile.txt
-            # don't backup the other home directories
-            - home/*
-            # don't even look in /dev, /proc, /run, /sys, /tmp (note: would exclude files like /device, too)
-            ! re:^(dev|proc|run|sys|tmp)
-
-        You can specify recursion roots either on the command line or in a patternfile::
-
-            # these two commands do the same thing
-            borg create --exclude home/bobby/junk archive /home/bobby /home/susan
-            borg create --patterns-from patternfile.lst archive
-
-        patternfile.lst::
-
-            # note that excludes use fm: by default and patternfiles use sh: by default.
-            # therefore, we need to specify fm: to have the same exact behavior.
-            P fm
-            R /home/bobby
-            R /home/susan
-            - home/bobby/junk
-
-        This allows you to share the same patterns between multiple repositories
-        without needing to specify them on the command line.\n\n"""
-    )
-    helptext["placeholders"] = textwrap.dedent(
-        """
-        Repository URLs, ``--name``, ``-a`` / ``--glob-archives``, ``--comment``
-        and ``--remote-path`` values support these placeholders:
-
-        {hostname}
-            The (short) hostname of the machine.
-
-        {fqdn}
-            The full name of the machine.
-
-        {reverse-fqdn}
-            The full name of the machine in reverse domain name notation.
-
-        {now}
-            The current local date and time, by default in ISO-8601 format.
-            You can also supply your own `format string <https://docs.python.org/3.9/library/datetime.html#strftime-and-strptime-behavior>`_, e.g. {now:%Y-%m-%d_%H:%M:%S}
-
-        {utcnow}
-            The current UTC date and time, by default in ISO-8601 format.
-            You can also supply your own `format string <https://docs.python.org/3.9/library/datetime.html#strftime-and-strptime-behavior>`_, e.g. {utcnow:%Y-%m-%d_%H:%M:%S}
-
-        {user}
-            The user name (or UID, if no name is available) of the user running borg.
-
-        {pid}
-            The current process ID.
-
-        {borgversion}
-            The version of borg, e.g.: 1.0.8rc1
-
-        {borgmajor}
-            The version of borg, only the major version, e.g.: 1
-
-        {borgminor}
-            The version of borg, only major and minor version, e.g.: 1.0
-
-        {borgpatch}
-            The version of borg, only major, minor and patch version, e.g.: 1.0.8
-
-        If literal curly braces need to be used, double them for escaping::
-
-            borg create /path/to/repo::{{literal_text}}
-
-        Examples::
-
-            borg create /path/to/repo::{hostname}-{user}-{utcnow} ...
-            borg create /path/to/repo::{hostname}-{now:%Y-%m-%d_%H:%M:%S} ...
-            borg prune -a '{hostname}-*' ...
-
-        .. note::
-            systemd uses a difficult, non-standard syntax for command lines in unit files (refer to
-            the `systemd.unit(5)` manual page).
-
-            When invoking borg from unit files, pay particular attention to escaping,
-            especially when using the now/utcnow placeholders, since systemd performs its own
-            %-based variable replacement even in quoted text. To avoid interference from systemd,
-            double all percent signs (``{hostname}-{now:%Y-%m-%d_%H:%M:%S}``
-            becomes ``{hostname}-{now:%%Y-%%m-%%d_%%H:%%M:%%S}``).\n\n"""
-    )
-    helptext["compression"] = textwrap.dedent(
-        """
-        It is no problem to mix different compression methods in one repo,
-        deduplication is done on the source data chunks (not on the compressed
-        or encrypted data).
-
-        If some specific chunk was once compressed and stored into the repo, creating
-        another backup that also uses this chunk will not change the stored chunk.
-        So if you use different compression specs for the backups, whichever stores a
-        chunk first determines its compression. See also borg recreate.
-
-        Compression is lz4 by default. If you want something else, you have to specify what you want.
-
-        Valid compression specifiers are:
-
-        none
-            Do not compress.
-
-        lz4
-            Use lz4 compression. Very high speed, very low compression. (default)
-
-        zstd[,L]
-            Use zstd ("zstandard") compression, a modern wide-range algorithm.
-            If you do not explicitly give the compression level L (ranging from 1
-            to 22), it will use level 3.
-            Archives compressed with zstd are not compatible with borg < 1.1.4.
-
-        zlib[,L]
-            Use zlib ("gz") compression. Medium speed, medium compression.
-            If you do not explicitly give the compression level L (ranging from 0
-            to 9), it will use level 6.
-            Giving level 0 (means "no compression", but still has zlib protocol
-            overhead) is usually pointless, you better use "none" compression.
-
-        lzma[,L]
-            Use lzma ("xz") compression. Low speed, high compression.
-            If you do not explicitly give the compression level L (ranging from 0
-            to 9), it will use level 6.
-            Giving levels above 6 is pointless and counterproductive because it does
-            not compress better due to the buffer size used by borg - but it wastes
-            lots of CPU cycles and RAM.
-
-        auto,C[,L]
-            Use a built-in heuristic to decide per chunk whether to compress or not.
-            The heuristic tries with lz4 whether the data is compressible.
-            For incompressible data, it will not use compression (uses "none").
-            For compressible data, it uses the given C[,L] compression - with C[,L]
-            being any valid compression specifier.
-
-        obfuscate,SPEC,C[,L]
-            Use compressed-size obfuscation to make fingerprinting attacks based on
-            the observable stored chunk size more difficult.
-            Note:
-            - you must combine this with encryption or it won't make any sense.
-            - your repo size will be bigger, of course.
-
-            The SPEC value will determine how the size obfuscation will work:
-
-            Relative random reciprocal size variation:
-            Size will increase by a factor, relative to the compressed data size.
-            Smaller factors are often used, larger factors rarely.
-            1: factor 0.01 .. 100.0
-            2: factor 0.1 .. 1000.0
-            3: factor 1.0 .. 10000.0
-            4: factor 10.0 .. 100000.0
-            5: factor 100.0 .. 1000000.0
-            6: factor 1000.0 .. 10000000.0
-
-            Add a randomly sized padding up to the given size:
-            110: 1kiB
-            ...
-            120: 1MiB
-            ...
-            123: 8MiB (max.)
-
-        Examples::
-
-            borg create --compression lz4 REPO::ARCHIVE data
-            borg create --compression zstd REPO::ARCHIVE data
-            borg create --compression zstd,10 REPO::ARCHIVE data
-            borg create --compression zlib REPO::ARCHIVE data
-            borg create --compression zlib,1 REPO::ARCHIVE data
-            borg create --compression auto,lzma,6 REPO::ARCHIVE data
-            borg create --compression auto,lzma ...
-            borg create --compression obfuscate,3,none ...
-            borg create --compression obfuscate,3,auto,zstd,10 ...
-            borg create --compression obfuscate,2,zstd,6 ...\n\n"""
-    )
-
-    def do_help(self, parser, commands, args):
-        if not args.topic:
-            parser.print_help()
-        elif args.topic in self.helptext:
-            print(rst_to_terminal(self.helptext[args.topic]))
-        elif args.topic in commands:
-            if args.epilog_only:
-                print(commands[args.topic].epilog)
-            elif args.usage_only:
-                commands[args.topic].epilog = None
-                commands[args.topic].print_help()
-            else:
-                commands[args.topic].print_help()
-        else:
-            msg_lines = []
-            msg_lines += ["No help available on %s." % args.topic]
-            msg_lines += ["Try one of the following:"]
-            msg_lines += ["    Commands: %s" % ", ".join(sorted(commands.keys()))]
-            msg_lines += ["    Topics: %s" % ", ".join(sorted(self.helptext.keys()))]
-            parser.error("\n".join(msg_lines))
-        return self.exit_code
-
-    def do_subcommand_help(self, parser, args):
-        """display infos about subcommand"""
-        parser.print_help()
-        return EXIT_SUCCESS
-
-    do_maincommand_help = do_subcommand_help
-
     def preprocess_args(self, args):
         deprecations = [
             # ('--old', '--new' or None, 'Warning: "--old" has been deprecated. Use "--new" instead.'),
@@ -2968,6 +2552,7 @@ class Archiver(DebugMixIn, TarMixIn, BenchmarkMixIn, KeysMixIn, LocksMixIn):
         subparser.add_argument("paths", metavar="PATH", nargs="*", type=str, help="paths to archive")
 
         self.build_parser_debug(subparsers, common_parser, mid_common_parser)
+        self.build_parser_help(subparsers, common_parser, mid_common_parser, parser)
 
         # borg rdelete
         rdelete_epilog = process_epilog(
@@ -3272,13 +2857,6 @@ class Archiver(DebugMixIn, TarMixIn, BenchmarkMixIn, KeysMixIn, LocksMixIn):
         )
         define_exclusion_group(subparser, strip_components=True)
 
-        # borg help
-        subparser = subparsers.add_parser("help", parents=[common_parser], add_help=False, description="Extra help")
-        subparser.add_argument("--epilog-only", dest="epilog_only", action="store_true")
-        subparser.add_argument("--usage-only", dest="usage_only", action="store_true")
-        subparser.set_defaults(func=functools.partial(self.do_help, parser, subparsers.choices))
-        subparser.add_argument("topic", metavar="TOPIC", type=str, nargs="?", help="additional help on TOPIC")
-
         # borg rinfo
         rinfo_epilog = process_epilog(
             """
diff --git a/src/borg/archiver/help.py b/src/borg/archiver/help.py
new file mode 100644
index 000000000..3d1c90b3a
--- /dev/null
+++ b/src/borg/archiver/help.py
@@ -0,0 +1,430 @@
+import collections
+import functools
+import textwrap
+
+from ..constants import *  # NOQA
+from ..nanorst import rst_to_terminal
+
+
+class HelpMixIn:
+    helptext = collections.OrderedDict()
+    helptext["patterns"] = textwrap.dedent(
+        """
+        When specifying one or more file paths in a Borg command that supports
+        patterns for the respective option or argument, you can apply the
+        patterns described here to include only desired files and/or exclude
+        unwanted ones. Patterns can be used
+
+        - for ``--exclude`` option,
+        - in the file given with ``--exclude-from`` option,
+        - for ``--pattern`` option,
+        - in the file given with ``--patterns-from`` option and
+        - for ``PATH`` arguments that explicitly support them.
+
+        Borg always stores all file paths normalized and relative to the
+        current recursion root. The recursion root is also named ``PATH`` in
+        Borg commands like `borg create` that do a file discovery, so do not
+        confuse the root with the ``PATH`` argument of e.g. `borg extract`.
+
+        Starting with Borg 1.2, paths that are matched against patterns always
+        appear relative. If you give ``/absolute/`` as root, the paths going
+        into the matcher will look relative like ``absolute/.../file.ext``.
+        If you give ``../some/path`` as root, the paths will look like
+        ``some/path/.../file.ext``.
+
+        File patterns support five different styles. If followed by a colon ':',
+        the first two characters of a pattern are used as a style selector.
+        Explicit style selection is necessary if a non-default style is desired
+        or when the desired pattern starts with two alphanumeric characters
+        followed by a colon (i.e. ``aa:something/*``).
+
+        `Fnmatch <https://docs.python.org/3/library/fnmatch.html>`_, selector ``fm:``
+            This is the default style for ``--exclude`` and ``--exclude-from``.
+            These patterns use a variant of shell pattern syntax, with '\\*' matching
+            any number of characters, '?' matching any single character, '[...]'
+            matching any single character specified, including ranges, and '[!...]'
+            matching any character not specified. For the purpose of these patterns,
+            the path separator (backslash for Windows and '/' on other systems) is not
+            treated specially. Wrap meta-characters in brackets for a literal
+            match (i.e. ``[?]`` to match the literal character '?'). For a path
+            to match a pattern, the full path must match, or it must match
+            from the start of the full path to just before a path separator. Except
+            for the root path, paths will never end in the path separator when
+            matching is attempted.  Thus, if a given pattern ends in a path
+            separator, a '\\*' is appended before matching is attempted. A leading
+            path separator is always removed.
+
+        Shell-style patterns, selector ``sh:``
+            This is the default style for ``--pattern`` and ``--patterns-from``.
+            Like fnmatch patterns these are similar to shell patterns. The difference
+            is that the pattern may include ``**/`` for matching zero or more directory
+            levels, ``*`` for matching zero or more arbitrary characters with the
+            exception of any path separator. A leading path separator is always removed.
+
+        `Regular expressions <https://docs.python.org/3/library/re.html>`_, selector ``re:``
+            Unlike shell patterns, regular expressions are not required to match the full
+            path and any substring match is sufficient. It is strongly recommended to
+            anchor patterns to the start ('^'), to the end ('$') or both. Path
+            separators (backslash for Windows and '/' on other systems) in paths are
+            always normalized to a forward slash '/' before applying a pattern.
+
+        Path prefix, selector ``pp:``
+            This pattern style is useful to match whole sub-directories. The pattern
+            ``pp:root/somedir`` matches ``root/somedir`` and everything therein.
+            A leading path separator is always removed.
+
+        Path full-match, selector ``pf:``
+            This pattern style is (only) useful to match full paths.
+            This is kind of a pseudo pattern as it can not have any variable or
+            unspecified parts - the full path must be given. ``pf:root/file.ext``
+            matches ``root/file.ext`` only. A leading path separator is always
+            removed.
+
+            Implementation note: this is implemented via very time-efficient O(1)
+            hashtable lookups (this means you can have huge amounts of such patterns
+            without impacting performance much).
+            Due to that, this kind of pattern does not respect any context or order.
+            If you use such a pattern to include a file, it will always be included
+            (if the directory recursion encounters it).
+            Other include/exclude patterns that would normally match will be ignored.
+            Same logic applies for exclude.
+
+        .. note::
+
+            ``re:``, ``sh:`` and ``fm:`` patterns are all implemented on top of
+            the Python SRE engine. It is very easy to formulate patterns for each
+            of these types which requires an inordinate amount of time to match
+            paths. If untrusted users are able to supply patterns, ensure they
+            cannot supply ``re:`` patterns. Further, ensure that ``sh:`` and
+            ``fm:`` patterns only contain a handful of wildcards at most.
+
+        Exclusions can be passed via the command line option ``--exclude``. When used
+        from within a shell, the patterns should be quoted to protect them from
+        expansion.
+
+        The ``--exclude-from`` option permits loading exclusion patterns from a text
+        file with one pattern per line. Lines empty or starting with the hash sign
+        '#' after removing whitespace on both ends are ignored. The optional style
+        selector prefix is also supported for patterns loaded from a file. Due to
+        whitespace removal, paths with whitespace at the beginning or end can only be
+        excluded using regular expressions.
+
+        To test your exclusion patterns without performing an actual backup you can
+        run ``borg create --list --dry-run ...``.
+
+        Examples::
+
+            # Exclude '/home/user/file.o' but not '/home/user/file.odt':
+            $ borg create -e '*.o' archive /
+
+            # Exclude '/home/user/junk' and '/home/user/subdir/junk' but
+            # not '/home/user/importantjunk' or '/etc/junk':
+            $ borg create -e 'home/*/junk' archive /
+
+            # Exclude the contents of '/home/user/cache' but not the directory itself:
+            $ borg create -e home/user/cache/ archive /
+
+            # The file '/home/user/cache/important' is *not* backed up:
+            $ borg create -e home/user/cache/ archive / /home/user/cache/important
+
+            # The contents of directories in '/home' are not backed up when their name
+            # ends in '.tmp'
+            $ borg create --exclude 're:^home/[^/]+\\.tmp/' archive /
+
+            # Load exclusions from file
+            $ cat >exclude.txt <<EOF
+            # Comment line
+            home/*/junk
+            *.tmp
+            fm:aa:something/*
+            re:^home/[^/]+\\.tmp/
+            sh:home/*/.thumbnails
+            # Example with spaces, no need to escape as it is processed by borg
+            some file with spaces.txt
+            EOF
+            $ borg create --exclude-from exclude.txt archive /
+
+        A more general and easier to use way to define filename matching patterns
+        exists with the ``--pattern`` and ``--patterns-from`` options. Using
+        these, you may specify the backup roots, default pattern styles and
+        patterns for inclusion and exclusion.
+
+        Root path prefix ``R``
+            A recursion root path starts with the prefix ``R``, followed by a path
+            (a plain path, not a file pattern). Use this prefix to have the root
+            paths in the patterns file rather than as command line arguments.
+
+        Pattern style prefix ``P``
+            To change the default pattern style, use the ``P`` prefix, followed by
+            the pattern style abbreviation (``fm``, ``pf``, ``pp``, ``re``, ``sh``).
+            All patterns following this line will use this style until another style
+            is specified.
+
+        Exclude pattern prefix ``-``
+            Use the prefix ``-``, followed by a pattern, to define an exclusion.
+            This has the same effect as the ``--exclude`` option.
+
+        Exclude no-recurse pattern prefix ``!``
+            Use the prefix ``!``, followed by a pattern, to define an exclusion
+            that does not recurse into subdirectories. This saves time, but
+            prevents include patterns to match any files in subdirectories.
+
+        Include pattern prefix ``+``
+            Use the prefix ``+``, followed by a pattern, to define inclusions.
+            This is useful to include paths that are covered in an exclude
+            pattern and would otherwise not be backed up.
+
+        The first matching pattern is used, so if an include pattern matches
+        before an exclude pattern, the file is backed up. Note that a no-recurse
+        exclude stops examination of subdirectories so that potential includes
+        will not match - use normal exludes for such use cases.
+
+        **Tip: You can easily test your patterns with --dry-run and  --list**::
+
+            $ borg create --dry-run --list --patterns-from patterns.txt archive
+
+        This will list the considered files one per line, prefixed with a
+        character that indicates the action (e.g. 'x' for excluding, see
+        **Item flags** in `borg create` usage docs).
+
+        .. note::
+
+            It's possible that a sub-directory/file is matched while parent
+            directories are not. In that case, parent directories are not backed
+            up and thus their user, group, permission, etc. cannot be restored.
+
+        Patterns (``--pattern``) and excludes (``--exclude``) from the command line are
+        considered first (in the order of appearance). Then patterns from ``--patterns-from``
+        are added. Exclusion patterns from ``--exclude-from`` files are appended last.
+
+        Examples::
+
+            # backup pics, but not the ones from 2018, except the good ones:
+            # note: using = is essential to avoid cmdline argument parsing issues.
+            borg create --pattern=+pics/2018/good --pattern=-pics/2018 archive pics
+
+            # backup only JPG/JPEG files (case insensitive) in all home directories:
+            borg create --pattern '+ re:\\.jpe?g(?i)$' archive /home
+
+            # backup homes, but exclude big downloads (like .ISO files) or hidden files:
+            borg create --exclude 're:\\.iso(?i)$' --exclude 'sh:home/**/.*' archive /home
+
+            # use a file with patterns (recursion root '/' via command line):
+            borg create --patterns-from patterns.lst archive /
+
+        The patterns.lst file could look like that::
+
+            # "sh:" pattern style is the default
+            # exclude caches
+            - home/*/.cache
+            # include susans home
+            + home/susan
+            # also back up this exact file
+            + pf:home/bobby/specialfile.txt
+            # don't backup the other home directories
+            - home/*
+            # don't even look in /dev, /proc, /run, /sys, /tmp (note: would exclude files like /device, too)
+            ! re:^(dev|proc|run|sys|tmp)
+
+        You can specify recursion roots either on the command line or in a patternfile::
+
+            # these two commands do the same thing
+            borg create --exclude home/bobby/junk archive /home/bobby /home/susan
+            borg create --patterns-from patternfile.lst archive
+
+        patternfile.lst::
+
+            # note that excludes use fm: by default and patternfiles use sh: by default.
+            # therefore, we need to specify fm: to have the same exact behavior.
+            P fm
+            R /home/bobby
+            R /home/susan
+            - home/bobby/junk
+
+        This allows you to share the same patterns between multiple repositories
+        without needing to specify them on the command line.\n\n"""
+    )
+    helptext["placeholders"] = textwrap.dedent(
+        """
+        Repository URLs, ``--name``, ``-a`` / ``--glob-archives``, ``--comment``
+        and ``--remote-path`` values support these placeholders:
+
+        {hostname}
+            The (short) hostname of the machine.
+
+        {fqdn}
+            The full name of the machine.
+
+        {reverse-fqdn}
+            The full name of the machine in reverse domain name notation.
+
+        {now}
+            The current local date and time, by default in ISO-8601 format.
+            You can also supply your own `format string <https://docs.python.org/3.9/library/datetime.html#strftime-and-strptime-behavior>`_, e.g. {now:%Y-%m-%d_%H:%M:%S}
+
+        {utcnow}
+            The current UTC date and time, by default in ISO-8601 format.
+            You can also supply your own `format string <https://docs.python.org/3.9/library/datetime.html#strftime-and-strptime-behavior>`_, e.g. {utcnow:%Y-%m-%d_%H:%M:%S}
+
+        {user}
+            The user name (or UID, if no name is available) of the user running borg.
+
+        {pid}
+            The current process ID.
+
+        {borgversion}
+            The version of borg, e.g.: 1.0.8rc1
+
+        {borgmajor}
+            The version of borg, only the major version, e.g.: 1
+
+        {borgminor}
+            The version of borg, only major and minor version, e.g.: 1.0
+
+        {borgpatch}
+            The version of borg, only major, minor and patch version, e.g.: 1.0.8
+
+        If literal curly braces need to be used, double them for escaping::
+
+            borg create /path/to/repo::{{literal_text}}
+
+        Examples::
+
+            borg create /path/to/repo::{hostname}-{user}-{utcnow} ...
+            borg create /path/to/repo::{hostname}-{now:%Y-%m-%d_%H:%M:%S} ...
+            borg prune -a '{hostname}-*' ...
+
+        .. note::
+            systemd uses a difficult, non-standard syntax for command lines in unit files (refer to
+            the `systemd.unit(5)` manual page).
+
+            When invoking borg from unit files, pay particular attention to escaping,
+            especially when using the now/utcnow placeholders, since systemd performs its own
+            %-based variable replacement even in quoted text. To avoid interference from systemd,
+            double all percent signs (``{hostname}-{now:%Y-%m-%d_%H:%M:%S}``
+            becomes ``{hostname}-{now:%%Y-%%m-%%d_%%H:%%M:%%S}``).\n\n"""
+    )
+    helptext["compression"] = textwrap.dedent(
+        """
+        It is no problem to mix different compression methods in one repo,
+        deduplication is done on the source data chunks (not on the compressed
+        or encrypted data).
+
+        If some specific chunk was once compressed and stored into the repo, creating
+        another backup that also uses this chunk will not change the stored chunk.
+        So if you use different compression specs for the backups, whichever stores a
+        chunk first determines its compression. See also borg recreate.
+
+        Compression is lz4 by default. If you want something else, you have to specify what you want.
+
+        Valid compression specifiers are:
+
+        none
+            Do not compress.
+
+        lz4
+            Use lz4 compression. Very high speed, very low compression. (default)
+
+        zstd[,L]
+            Use zstd ("zstandard") compression, a modern wide-range algorithm.
+            If you do not explicitly give the compression level L (ranging from 1
+            to 22), it will use level 3.
+            Archives compressed with zstd are not compatible with borg < 1.1.4.
+
+        zlib[,L]
+            Use zlib ("gz") compression. Medium speed, medium compression.
+            If you do not explicitly give the compression level L (ranging from 0
+            to 9), it will use level 6.
+            Giving level 0 (means "no compression", but still has zlib protocol
+            overhead) is usually pointless, you better use "none" compression.
+
+        lzma[,L]
+            Use lzma ("xz") compression. Low speed, high compression.
+            If you do not explicitly give the compression level L (ranging from 0
+            to 9), it will use level 6.
+            Giving levels above 6 is pointless and counterproductive because it does
+            not compress better due to the buffer size used by borg - but it wastes
+            lots of CPU cycles and RAM.
+
+        auto,C[,L]
+            Use a built-in heuristic to decide per chunk whether to compress or not.
+            The heuristic tries with lz4 whether the data is compressible.
+            For incompressible data, it will not use compression (uses "none").
+            For compressible data, it uses the given C[,L] compression - with C[,L]
+            being any valid compression specifier.
+
+        obfuscate,SPEC,C[,L]
+            Use compressed-size obfuscation to make fingerprinting attacks based on
+            the observable stored chunk size more difficult.
+            Note:
+            - you must combine this with encryption or it won't make any sense.
+            - your repo size will be bigger, of course.
+
+            The SPEC value will determine how the size obfuscation will work:
+
+            Relative random reciprocal size variation:
+            Size will increase by a factor, relative to the compressed data size.
+            Smaller factors are often used, larger factors rarely.
+            1: factor 0.01 .. 100.0
+            2: factor 0.1 .. 1000.0
+            3: factor 1.0 .. 10000.0
+            4: factor 10.0 .. 100000.0
+            5: factor 100.0 .. 1000000.0
+            6: factor 1000.0 .. 10000000.0
+
+            Add a randomly sized padding up to the given size:
+            110: 1kiB
+            ...
+            120: 1MiB
+            ...
+            123: 8MiB (max.)
+
+        Examples::
+
+            borg create --compression lz4 REPO::ARCHIVE data
+            borg create --compression zstd REPO::ARCHIVE data
+            borg create --compression zstd,10 REPO::ARCHIVE data
+            borg create --compression zlib REPO::ARCHIVE data
+            borg create --compression zlib,1 REPO::ARCHIVE data
+            borg create --compression auto,lzma,6 REPO::ARCHIVE data
+            borg create --compression auto,lzma ...
+            borg create --compression obfuscate,3,none ...
+            borg create --compression obfuscate,3,auto,zstd,10 ...
+            borg create --compression obfuscate,2,zstd,6 ...\n\n"""
+    )
+
+    def do_help(self, parser, commands, args):
+        if not args.topic:
+            parser.print_help()
+        elif args.topic in self.helptext:
+            print(rst_to_terminal(self.helptext[args.topic]))
+        elif args.topic in commands:
+            if args.epilog_only:
+                print(commands[args.topic].epilog)
+            elif args.usage_only:
+                commands[args.topic].epilog = None
+                commands[args.topic].print_help()
+            else:
+                commands[args.topic].print_help()
+        else:
+            msg_lines = []
+            msg_lines += ["No help available on %s." % args.topic]
+            msg_lines += ["Try one of the following:"]
+            msg_lines += ["    Commands: %s" % ", ".join(sorted(commands.keys()))]
+            msg_lines += ["    Topics: %s" % ", ".join(sorted(self.helptext.keys()))]
+            parser.error("\n".join(msg_lines))
+        return self.exit_code
+
+    def do_subcommand_help(self, parser, args):
+        """display infos about subcommand"""
+        parser.print_help()
+        return EXIT_SUCCESS
+
+    do_maincommand_help = do_subcommand_help
+
+    def build_parser_help(self, subparsers, common_parser, mid_common_parser, parser):
+        subparser = subparsers.add_parser("help", parents=[common_parser], add_help=False, description="Extra help")
+        subparser.add_argument("--epilog-only", dest="epilog_only", action="store_true")
+        subparser.add_argument("--usage-only", dest="usage_only", action="store_true")
+        subparser.set_defaults(func=functools.partial(self.do_help, parser, subparsers.choices))
+        subparser.add_argument("topic", metavar="TOPIC", type=str, nargs="?", help="additional help on TOPIC")

From 8d9e47e374af139946b45441ad3765e2510257e1 Mon Sep 17 00:00:00 2001
From: Thomas Waldmann <tw@waldmann-edv.de>
Date: Fri, 8 Jul 2022 04:29:54 +0200
Subject: [PATCH 124/160] move transfer command to archiver.transfer

---
 src/borg/archiver/__init__.py | 202 ++--------------------------------
 src/borg/archiver/common.py   |  54 ++++++++-
 src/borg/archiver/transfer.py | 159 ++++++++++++++++++++++++++
 3 files changed, 220 insertions(+), 195 deletions(-)
 create mode 100644 src/borg/archiver/transfer.py

diff --git a/src/borg/archiver/__init__.py b/src/borg/archiver/__init__.py
index bbea5b7e0..9a67e88a0 100644
--- a/src/borg/archiver/__init__.py
+++ b/src/borg/archiver/__init__.py
@@ -40,15 +40,15 @@ try:
     from ..crypto.key import key_creator, key_argument_names, tam_required_file
     from ..helpers import EXIT_SUCCESS, EXIT_WARNING, EXIT_ERROR, EXIT_SIGNAL_BASE
     from ..helpers import Error, NoManifestError, set_ec
-    from ..helpers import positive_int_validator, location_validator, archivename_validator, ChunkerParams, Location
-    from ..helpers import GlobSpec, NameSpec, CommentSpec, SortBySpec, FilesCacheMode
+    from ..helpers import location_validator, archivename_validator, ChunkerParams, Location
+    from ..helpers import NameSpec, CommentSpec, FilesCacheMode
     from ..helpers import BaseFormatter, ItemFormatter, ArchiveFormatter
     from ..helpers import format_timedelta, format_file_size, parse_file_size, format_archive
     from ..helpers import remove_surrogates, bin_to_hex, eval_escapes
     from ..helpers import interval, prune_within, prune_split, PRUNING_PATTERNS
     from ..helpers import timestamp
     from ..helpers import get_cache_dir, os_stat
-    from ..helpers import Manifest, AI_HUMAN_SORT_KEYS
+    from ..helpers import Manifest
     from ..helpers import HardLinkManager
     from ..helpers import check_python, check_extension_modules
     from ..helpers import dir_is_tagged, is_slow_msgpack, is_supported_msgpack, yes, sysinfo
@@ -107,9 +107,10 @@ from .help import HelpMixIn
 from .keys import KeysMixIn
 from .locks import LocksMixIn
 from .tar import TarMixIn
+from .transfer import TransferMixIn
 
 
-class Archiver(DebugMixIn, TarMixIn, BenchmarkMixIn, KeysMixIn, LocksMixIn, HelpMixIn):
+class Archiver(DebugMixIn, TarMixIn, BenchmarkMixIn, KeysMixIn, LocksMixIn, HelpMixIn, TransferMixIn):
     def __init__(self, lock_wait=None, prog=None):
         self.exit_code = EXIT_SUCCESS
         self.lock_wait = lock_wait
@@ -153,84 +154,6 @@ class Archiver(DebugMixIn, TarMixIn, BenchmarkMixIn, KeysMixIn, LocksMixIn, Help
         ).serve()
         return EXIT_SUCCESS
 
-    @with_other_repository(manifest=True, key=True, compatibility=(Manifest.Operation.READ,))
-    @with_repository(exclusive=True, manifest=True, cache=True, compatibility=(Manifest.Operation.WRITE,))
-    def do_transfer(
-        self, args, *, repository, manifest, key, cache, other_repository=None, other_manifest=None, other_key=None
-    ):
-        """archives transfer from other repository, optionally upgrade data format"""
-        dry_run = args.dry_run
-        args.consider_checkpoints = True
-        archive_names = tuple(x.name for x in other_manifest.archives.list_considering(args))
-        if not archive_names:
-            return EXIT_SUCCESS
-
-        from . import upgrade as upgrade_mod
-
-        try:
-            UpgraderCls = getattr(upgrade_mod, f"Upgrader{args.upgrader}")
-        except AttributeError:
-            self.print_error(f"No such upgrader: {args.upgrader}")
-            return EXIT_ERROR
-
-        upgrader = UpgraderCls(cache=cache)
-
-        for name in archive_names:
-            transfer_size = 0
-            present_size = 0
-            if name in manifest.archives and not dry_run:
-                print(f"{name}: archive is already present in destination repo, skipping.")
-            else:
-                if not dry_run:
-                    print(f"{name}: copying archive to destination repo...")
-                other_archive = Archive(other_repository, other_key, other_manifest, name)
-                archive = Archive(repository, key, manifest, name, cache=cache, create=True) if not dry_run else None
-                upgrader.new_archive(archive=archive)
-                for item in other_archive.iter_items():
-                    if "chunks" in item:
-                        chunks = []
-                        for chunk_id, size in item.chunks:
-                            refcount = cache.seen_chunk(chunk_id, size)
-                            if refcount == 0:  # target repo does not yet have this chunk
-                                if not dry_run:
-                                    cdata = other_repository.get(chunk_id)
-                                    # keep compressed payload same, avoid decompression / recompression
-                                    data = other_key.decrypt(chunk_id, cdata, decompress=False)
-                                    data = upgrader.upgrade_compressed_chunk(chunk=data)
-                                    chunk_entry = cache.add_chunk(
-                                        chunk_id, data, archive.stats, wait=False, compress=False, size=size
-                                    )
-                                    cache.repository.async_response(wait=False)
-                                    chunks.append(chunk_entry)
-                                transfer_size += size
-                            else:
-                                if not dry_run:
-                                    chunk_entry = cache.chunk_incref(chunk_id, archive.stats)
-                                    chunks.append(chunk_entry)
-                                present_size += size
-                        if not dry_run:
-                            item.chunks = chunks  # TODO: overwrite? IDs and sizes are same.
-                            archive.stats.nfiles += 1
-                    if not dry_run:
-                        archive.add_item(upgrader.upgrade_item(item=item))
-                if not dry_run:
-                    additional_metadata = upgrader.upgrade_archive_metadata(metadata=other_archive.metadata)
-                    archive.save(stats=archive.stats, additional_metadata=additional_metadata)
-                    print(
-                        f"{name}: finished. "
-                        f"transfer_size: {format_file_size(transfer_size)} "
-                        f"present_size: {format_file_size(present_size)}"
-                    )
-                else:
-                    print(
-                        f"{name}: completed"
-                        if transfer_size == 0
-                        else f"{name}: incomplete, "
-                        f"transfer_size: {format_file_size(transfer_size)} "
-                        f"present_size: {format_file_size(present_size)}"
-                    )
-        return EXIT_SUCCESS
-
     @with_repository(create=True, exclusive=True, manifest=False)
     @with_other_repository(key=True, compatibility=(Manifest.Operation.READ,))
     def do_rcreate(self, args, repository, *, other_repository=None, other_key=None):
@@ -1659,7 +1582,7 @@ class Archiver(DebugMixIn, TarMixIn, BenchmarkMixIn, KeysMixIn, LocksMixIn, Help
     def build_parser(self):
 
         from .common import process_epilog
-        from .common import define_exclusion_group
+        from .common import define_exclusion_group, define_archive_filters_group
 
         def define_common_options(add_common_option):
             add_common_option("-h", "--help", action="help", help="show this help message and exit")
@@ -1801,55 +1724,6 @@ class Archiver(DebugMixIn, TarMixIn, BenchmarkMixIn, KeysMixIn, LocksMixIn, Help
                 help="repository to use",
             )
 
-        def define_archive_filters_group(subparser, *, sort_by=True, first_last=True):
-            filters_group = subparser.add_argument_group(
-                "Archive filters", "Archive filters can be applied to repository targets."
-            )
-            group = filters_group.add_mutually_exclusive_group()
-            group.add_argument(
-                "-a",
-                "--glob-archives",
-                metavar="GLOB",
-                dest="glob_archives",
-                type=GlobSpec,
-                action=Highlander,
-                help="only consider archive names matching the glob. " 'sh: rules apply, see "borg help patterns".',
-            )
-
-            if sort_by:
-                sort_by_default = "timestamp"
-                filters_group.add_argument(
-                    "--sort-by",
-                    metavar="KEYS",
-                    dest="sort_by",
-                    type=SortBySpec,
-                    default=sort_by_default,
-                    help="Comma-separated list of sorting keys; valid keys are: {}; default is: {}".format(
-                        ", ".join(AI_HUMAN_SORT_KEYS), sort_by_default
-                    ),
-                )
-
-            if first_last:
-                group = filters_group.add_mutually_exclusive_group()
-                group.add_argument(
-                    "--first",
-                    metavar="N",
-                    dest="first",
-                    default=0,
-                    type=positive_int_validator,
-                    help="consider first N archives after other filters were applied",
-                )
-                group.add_argument(
-                    "--last",
-                    metavar="N",
-                    dest="last",
-                    default=0,
-                    type=positive_int_validator,
-                    help="consider last N archives after other filters were applied",
-                )
-
-            return filters_group
-
         def define_borg_mount(parser):
             parser.set_defaults(func=self.do_mount)
             parser.add_argument(
@@ -2670,68 +2544,6 @@ class Archiver(DebugMixIn, TarMixIn, BenchmarkMixIn, KeysMixIn, LocksMixIn, Help
         )
         define_archive_filters_group(subparser)
 
-        # borg transfer
-        transfer_epilog = process_epilog(
-            """
-        This command transfers archives from one repository to another repository.
-        Optionally, it can also upgrade the transferred data.
-
-        Suggested use for general purpose archive transfer (not repo upgrades)::
-
-            # initialize DST_REPO reusing key material from SRC_REPO, so that
-            # chunking and chunk id generation will work in the same way as before.
-            borg --repo=DST_REPO init --other-repo=SRC_REPO --encryption=DST_ENC
-
-            # transfer archives from SRC_REPO to DST_REPO
-            borg --repo=DST_REPO transfer --other-repo=SRC_REPO --dry-run  # check what it would do
-            borg --repo=DST_REPO transfer --other-repo=SRC_REPO            # do it!
-            borg --repo=DST_REPO transfer --other-repo=SRC_REPO --dry-run  # check! anything left?
-
-        The default is to transfer all archives, including checkpoint archives.
-
-        You could use the misc. archive filter options to limit which archives it will
-        transfer, e.g. using the -a option. This is recommended for big
-        repositories with multiple data sets to keep the runtime per invocation lower.
-
-        For repository upgrades (e.g. from a borg 1.2 repo to a related borg 2.0 repo), usage is
-        quite similar to the above::
-
-            borg --repo=DST_REPO transfer --other-repo=SRC_REPO --upgrader=From12To20
-
-
-        """
-        )
-        subparser = subparsers.add_parser(
-            "transfer",
-            parents=[common_parser],
-            add_help=False,
-            description=self.do_transfer.__doc__,
-            epilog=transfer_epilog,
-            formatter_class=argparse.RawDescriptionHelpFormatter,
-            help="transfer of archives from another repository",
-        )
-        subparser.set_defaults(func=self.do_transfer)
-        subparser.add_argument(
-            "-n", "--dry-run", dest="dry_run", action="store_true", help="do not change repository, just check"
-        )
-        subparser.add_argument(
-            "--other-repo",
-            metavar="SRC_REPOSITORY",
-            dest="other_location",
-            type=location_validator(other=True),
-            default=Location(other=True),
-            help="transfer archives from the other repository",
-        )
-        subparser.add_argument(
-            "--upgrader",
-            metavar="UPGRADER",
-            dest="upgrader",
-            type=str,
-            default="NoOp",
-            help="use the upgrader to convert transferred data (default: no conversion)",
-        )
-        define_archive_filters_group(subparser)
-
         # borg diff
         diff_epilog = process_epilog(
             """
@@ -3632,6 +3444,8 @@ class Archiver(DebugMixIn, TarMixIn, BenchmarkMixIn, KeysMixIn, LocksMixIn, Help
 
         self.build_parser_tar(subparsers, common_parser, mid_common_parser)
 
+        self.build_parser_transfer(subparsers, common_parser, mid_common_parser)
+
         return parser
 
     def get_args(self, argv, cmd):
diff --git a/src/borg/archiver/common.py b/src/borg/archiver/common.py
index d0c07bf00..3be4c1466 100644
--- a/src/borg/archiver/common.py
+++ b/src/borg/archiver/common.py
@@ -7,7 +7,8 @@ from ..archive import Archive
 from ..constants import *  # NOQA
 from ..cache import Cache, assert_secure
 from ..helpers import Error
-from ..helpers import Manifest
+from ..helpers import Manifest, AI_HUMAN_SORT_KEYS
+from ..helpers import GlobSpec, SortBySpec, positive_int_validator
 from ..remote import RemoteRepository
 from ..repository import Repository
 from ..nanorst import rst_to_terminal
@@ -18,6 +19,7 @@ from ..patterns import (
     parse_exclude_pattern,
 )
 
+
 from ..logger import create_logger
 
 logger = create_logger(__name__)
@@ -368,3 +370,53 @@ def define_exclusion_group(subparser, **kwargs):
     exclude_group = subparser.add_argument_group("Exclusion options")
     define_exclude_and_patterns(exclude_group.add_argument, **kwargs)
     return exclude_group
+
+
+def define_archive_filters_group(subparser, *, sort_by=True, first_last=True):
+    filters_group = subparser.add_argument_group(
+        "Archive filters", "Archive filters can be applied to repository targets."
+    )
+    group = filters_group.add_mutually_exclusive_group()
+    group.add_argument(
+        "-a",
+        "--glob-archives",
+        metavar="GLOB",
+        dest="glob_archives",
+        type=GlobSpec,
+        action=Highlander,
+        help="only consider archive names matching the glob. " 'sh: rules apply, see "borg help patterns".',
+    )
+
+    if sort_by:
+        sort_by_default = "timestamp"
+        filters_group.add_argument(
+            "--sort-by",
+            metavar="KEYS",
+            dest="sort_by",
+            type=SortBySpec,
+            default=sort_by_default,
+            help="Comma-separated list of sorting keys; valid keys are: {}; default is: {}".format(
+                ", ".join(AI_HUMAN_SORT_KEYS), sort_by_default
+            ),
+        )
+
+    if first_last:
+        group = filters_group.add_mutually_exclusive_group()
+        group.add_argument(
+            "--first",
+            metavar="N",
+            dest="first",
+            default=0,
+            type=positive_int_validator,
+            help="consider first N archives after other filters were applied",
+        )
+        group.add_argument(
+            "--last",
+            metavar="N",
+            dest="last",
+            default=0,
+            type=positive_int_validator,
+            help="consider last N archives after other filters were applied",
+        )
+
+    return filters_group
diff --git a/src/borg/archiver/transfer.py b/src/borg/archiver/transfer.py
new file mode 100644
index 000000000..62f8f0ac7
--- /dev/null
+++ b/src/borg/archiver/transfer.py
@@ -0,0 +1,159 @@
+import argparse
+
+from .common import with_repository, with_other_repository
+from ..archive import Archive
+from ..constants import *  # NOQA
+from ..helpers import EXIT_SUCCESS, EXIT_ERROR
+from ..helpers import location_validator, Location
+from ..helpers import format_file_size
+from ..helpers import Manifest
+
+from ..logger import create_logger
+
+logger = create_logger()
+
+
+class TransferMixIn:
+    @with_other_repository(manifest=True, key=True, compatibility=(Manifest.Operation.READ,))
+    @with_repository(exclusive=True, manifest=True, cache=True, compatibility=(Manifest.Operation.WRITE,))
+    def do_transfer(
+        self, args, *, repository, manifest, key, cache, other_repository=None, other_manifest=None, other_key=None
+    ):
+        """archives transfer from other repository, optionally upgrade data format"""
+        dry_run = args.dry_run
+        args.consider_checkpoints = True
+        archive_names = tuple(x.name for x in other_manifest.archives.list_considering(args))
+        if not archive_names:
+            return EXIT_SUCCESS
+
+        from .. import upgrade as upgrade_mod
+
+        try:
+            UpgraderCls = getattr(upgrade_mod, f"Upgrader{args.upgrader}")
+        except AttributeError:
+            self.print_error(f"No such upgrader: {args.upgrader}")
+            return EXIT_ERROR
+
+        upgrader = UpgraderCls(cache=cache)
+
+        for name in archive_names:
+            transfer_size = 0
+            present_size = 0
+            if name in manifest.archives and not dry_run:
+                print(f"{name}: archive is already present in destination repo, skipping.")
+            else:
+                if not dry_run:
+                    print(f"{name}: copying archive to destination repo...")
+                other_archive = Archive(other_repository, other_key, other_manifest, name)
+                archive = Archive(repository, key, manifest, name, cache=cache, create=True) if not dry_run else None
+                upgrader.new_archive(archive=archive)
+                for item in other_archive.iter_items():
+                    if "chunks" in item:
+                        chunks = []
+                        for chunk_id, size in item.chunks:
+                            refcount = cache.seen_chunk(chunk_id, size)
+                            if refcount == 0:  # target repo does not yet have this chunk
+                                if not dry_run:
+                                    cdata = other_repository.get(chunk_id)
+                                    # keep compressed payload same, avoid decompression / recompression
+                                    data = other_key.decrypt(chunk_id, cdata, decompress=False)
+                                    data = upgrader.upgrade_compressed_chunk(chunk=data)
+                                    chunk_entry = cache.add_chunk(
+                                        chunk_id, data, archive.stats, wait=False, compress=False, size=size
+                                    )
+                                    cache.repository.async_response(wait=False)
+                                    chunks.append(chunk_entry)
+                                transfer_size += size
+                            else:
+                                if not dry_run:
+                                    chunk_entry = cache.chunk_incref(chunk_id, archive.stats)
+                                    chunks.append(chunk_entry)
+                                present_size += size
+                        if not dry_run:
+                            item.chunks = chunks  # TODO: overwrite? IDs and sizes are same.
+                            archive.stats.nfiles += 1
+                    if not dry_run:
+                        archive.add_item(upgrader.upgrade_item(item=item))
+                if not dry_run:
+                    additional_metadata = upgrader.upgrade_archive_metadata(metadata=other_archive.metadata)
+                    archive.save(stats=archive.stats, additional_metadata=additional_metadata)
+                    print(
+                        f"{name}: finished. "
+                        f"transfer_size: {format_file_size(transfer_size)} "
+                        f"present_size: {format_file_size(present_size)}"
+                    )
+                else:
+                    print(
+                        f"{name}: completed"
+                        if transfer_size == 0
+                        else f"{name}: incomplete, "
+                        f"transfer_size: {format_file_size(transfer_size)} "
+                        f"present_size: {format_file_size(present_size)}"
+                    )
+        return EXIT_SUCCESS
+
+    def build_parser_transfer(self, subparsers, common_parser, mid_common_parser):
+
+        from .common import process_epilog
+        from .common import define_archive_filters_group
+
+        transfer_epilog = process_epilog(
+            """
+        This command transfers archives from one repository to another repository.
+        Optionally, it can also upgrade the transferred data.
+
+        Suggested use for general purpose archive transfer (not repo upgrades)::
+
+            # initialize DST_REPO reusing key material from SRC_REPO, so that
+            # chunking and chunk id generation will work in the same way as before.
+            borg --repo=DST_REPO init --other-repo=SRC_REPO --encryption=DST_ENC
+
+            # transfer archives from SRC_REPO to DST_REPO
+            borg --repo=DST_REPO transfer --other-repo=SRC_REPO --dry-run  # check what it would do
+            borg --repo=DST_REPO transfer --other-repo=SRC_REPO            # do it!
+            borg --repo=DST_REPO transfer --other-repo=SRC_REPO --dry-run  # check! anything left?
+
+        The default is to transfer all archives, including checkpoint archives.
+
+        You could use the misc. archive filter options to limit which archives it will
+        transfer, e.g. using the -a option. This is recommended for big
+        repositories with multiple data sets to keep the runtime per invocation lower.
+
+        For repository upgrades (e.g. from a borg 1.2 repo to a related borg 2.0 repo), usage is
+        quite similar to the above::
+
+            borg --repo=DST_REPO transfer --other-repo=SRC_REPO --upgrader=From12To20
+
+
+        """
+        )
+        subparser = subparsers.add_parser(
+            "transfer",
+            parents=[common_parser],
+            add_help=False,
+            description=self.do_transfer.__doc__,
+            epilog=transfer_epilog,
+            formatter_class=argparse.RawDescriptionHelpFormatter,
+            help="transfer of archives from another repository",
+        )
+        subparser.set_defaults(func=self.do_transfer)
+        subparser.add_argument(
+            "-n", "--dry-run", dest="dry_run", action="store_true", help="do not change repository, just check"
+        )
+        subparser.add_argument(
+            "--other-repo",
+            metavar="SRC_REPOSITORY",
+            dest="other_location",
+            type=location_validator(other=True),
+            default=Location(other=True),
+            help="transfer archives from the other repository",
+        )
+        subparser.add_argument(
+            "--upgrader",
+            metavar="UPGRADER",
+            dest="upgrader",
+            type=str,
+            default="NoOp",
+            help="use the upgrader to convert transferred data (default: no conversion)",
+        )
+        define_archive_filters_group(subparser)

From 94e6477e517646dea83669128716a44580d96081 Mon Sep 17 00:00:00 2001
From: Thomas Waldmann <tw@waldmann-edv.de>
Date: Fri, 8 Jul 2022 21:48:05 +0200
Subject: [PATCH 125/160] move config command to archiver.config

---
 setup.cfg                     |   1 +
 src/borg/archiver/__init__.py | 180 +------------------------------
 src/borg/archiver/config.py   | 194 ++++++++++++++++++++++++++++++++++
 3 files changed, 199 insertions(+), 176 deletions(-)
 create mode 100644 src/borg/archiver/config.py

diff --git a/setup.cfg b/setup.cfg
index 3db6c8a97..dd9230179 100644
--- a/setup.cfg
+++ b/setup.cfg
@@ -118,6 +118,7 @@ per_file_ignores =
     src/borg/archive.py:E122,E125,E127,E402,E501,F401,F405,W504
     src/borg/archiver/__init__.py:E402,E501,E722,E741,F405
     src/borg/archiver/benchmarks.py:F405
+    src/borg/archiver/config.py:F405,E722
     src/borg/archiver/common.py:E501,F405
     src/borg/archiver/debug.py:F405
     src/borg/archiver/help.py:E501,F405
diff --git a/src/borg/archiver/__init__.py b/src/borg/archiver/__init__.py
index 9a67e88a0..45e3702da 100644
--- a/src/borg/archiver/__init__.py
+++ b/src/borg/archiver/__init__.py
@@ -5,7 +5,6 @@ import traceback
 
 try:
     import argparse
-    import configparser
     import faulthandler
     import functools
     import inspect
@@ -20,7 +19,6 @@ try:
     import subprocess
     import textwrap
     import time
-    from binascii import unhexlify
     from datetime import datetime, timedelta
     from io import TextIOWrapper
 
@@ -34,7 +32,7 @@ try:
     from ..archive import Archive, ArchiveChecker, ArchiveRecreater, Statistics, is_special
     from ..archive import BackupError, BackupOSError, backup_io, OsOpen, stat_update_check
     from ..archive import FilesystemObjectProcessors, MetadataCollector, ChunksProcessor
-    from ..cache import Cache, assert_secure, SecurityManager
+    from ..cache import Cache, SecurityManager
     from ..constants import *  # NOQA
     from ..compress import CompressionSpec
     from ..crypto.key import key_creator, key_argument_names, tam_required_file
@@ -102,6 +100,7 @@ def get_func(args):
 
 
 from .benchmarks import BenchmarkMixIn
+from .config import ConfigMixIn
 from .debug import DebugMixIn
 from .help import HelpMixIn
 from .keys import KeysMixIn
@@ -110,7 +109,7 @@ from .tar import TarMixIn
 from .transfer import TransferMixIn
 
 
-class Archiver(DebugMixIn, TarMixIn, BenchmarkMixIn, KeysMixIn, LocksMixIn, HelpMixIn, TransferMixIn):
+class Archiver(ConfigMixIn, DebugMixIn, TarMixIn, BenchmarkMixIn, KeysMixIn, LocksMixIn, HelpMixIn, TransferMixIn):
     def __init__(self, lock_wait=None, prog=None):
         self.exit_code = EXIT_SUCCESS
         self.lock_wait = lock_wait
@@ -1308,137 +1307,6 @@ class Archiver(DebugMixIn, TarMixIn, BenchmarkMixIn, KeysMixIn, LocksMixIn, Help
         repository.commit(compact=True, threshold=threshold)
         return EXIT_SUCCESS
 
-    @with_repository(exclusive=True, manifest=False)
-    def do_config(self, args, repository):
-        """get, set, and delete values in a repository or cache config file"""
-
-        def repo_validate(section, name, value=None, check_value=True):
-            if section not in ["repository"]:
-                raise ValueError("Invalid section")
-            if name in ["segments_per_dir", "last_segment_checked"]:
-                if check_value:
-                    try:
-                        int(value)
-                    except ValueError:
-                        raise ValueError("Invalid value") from None
-            elif name in ["max_segment_size", "additional_free_space", "storage_quota"]:
-                if check_value:
-                    try:
-                        parse_file_size(value)
-                    except ValueError:
-                        raise ValueError("Invalid value") from None
-                    if name == "storage_quota":
-                        if parse_file_size(value) < parse_file_size("10M"):
-                            raise ValueError("Invalid value: storage_quota < 10M")
-                    elif name == "max_segment_size":
-                        if parse_file_size(value) >= MAX_SEGMENT_SIZE_LIMIT:
-                            raise ValueError("Invalid value: max_segment_size >= %d" % MAX_SEGMENT_SIZE_LIMIT)
-            elif name in ["append_only"]:
-                if check_value and value not in ["0", "1"]:
-                    raise ValueError("Invalid value")
-            elif name in ["id"]:
-                if check_value:
-                    try:
-                        bin_id = unhexlify(value)
-                    except:
-                        raise ValueError("Invalid value, must be 64 hex digits") from None
-                    if len(bin_id) != 32:
-                        raise ValueError("Invalid value, must be 64 hex digits")
-            else:
-                raise ValueError("Invalid name")
-
-        def cache_validate(section, name, value=None, check_value=True):
-            if section not in ["cache"]:
-                raise ValueError("Invalid section")
-            if name in ["previous_location"]:
-                if check_value:
-                    Location(value)
-            else:
-                raise ValueError("Invalid name")
-
-        def list_config(config):
-            default_values = {
-                "version": "1",
-                "segments_per_dir": str(DEFAULT_SEGMENTS_PER_DIR),
-                "max_segment_size": str(MAX_SEGMENT_SIZE_LIMIT),
-                "additional_free_space": "0",
-                "storage_quota": repository.storage_quota,
-                "append_only": repository.append_only,
-            }
-            print("[repository]")
-            for key in [
-                "version",
-                "segments_per_dir",
-                "max_segment_size",
-                "storage_quota",
-                "additional_free_space",
-                "append_only",
-                "id",
-            ]:
-                value = config.get("repository", key, fallback=False)
-                if value is None:
-                    value = default_values.get(key)
-                    if value is None:
-                        raise Error("The repository config is missing the %s key which has no default value" % key)
-                print(f"{key} = {value}")
-            for key in ["last_segment_checked"]:
-                value = config.get("repository", key, fallback=None)
-                if value is None:
-                    continue
-                print(f"{key} = {value}")
-
-        if not args.list:
-            if args.name is None:
-                self.print_error("No config key name was provided.")
-                return self.exit_code
-
-            try:
-                section, name = args.name.split(".")
-            except ValueError:
-                section = args.cache and "cache" or "repository"
-                name = args.name
-
-        if args.cache:
-            manifest, key = Manifest.load(repository, (Manifest.Operation.WRITE,))
-            assert_secure(repository, manifest, self.lock_wait)
-            cache = Cache(repository, key, manifest, lock_wait=self.lock_wait)
-
-        try:
-            if args.cache:
-                cache.cache_config.load()
-                config = cache.cache_config._config
-                save = cache.cache_config.save
-                validate = cache_validate
-            else:
-                config = repository.config
-                save = lambda: repository.save_config(repository.path, repository.config)  # noqa
-                validate = repo_validate
-
-            if args.delete:
-                validate(section, name, check_value=False)
-                config.remove_option(section, name)
-                if len(config.options(section)) == 0:
-                    config.remove_section(section)
-                save()
-            elif args.list:
-                list_config(config)
-            elif args.value:
-                validate(section, name, args.value)
-                if section not in config.sections():
-                    config.add_section(section)
-                config.set(section, name, args.value)
-                save()
-            else:
-                try:
-                    print(config.get(section, name))
-                except (configparser.NoOptionError, configparser.NoSectionError) as e:
-                    print(e, file=sys.stderr)
-                    return EXIT_WARNING
-            return EXIT_SUCCESS
-        finally:
-            if args.cache:
-                cache.close()
-
     def preprocess_args(self, args):
         deprecations = [
             # ('--old', '--new' or None, 'Warning: "--old" has been deprecated. Use "--new" instead.'),
@@ -2003,47 +1871,6 @@ class Archiver(DebugMixIn, TarMixIn, BenchmarkMixIn, KeysMixIn, LocksMixIn, Help
             help="set minimum threshold for saved space in PERCENT (Default: 10)",
         )
 
-        # borg config
-        config_epilog = process_epilog(
-            """
-        This command gets and sets options in a local repository or cache config file.
-        For security reasons, this command only works on local repositories.
-
-        To delete a config value entirely, use ``--delete``. To list the values
-        of the configuration file or the default values, use ``--list``.  To get and existing
-        key, pass only the key name. To set a key, pass both the key name and
-        the new value. Keys can be specified in the format "section.name" or
-        simply "name"; the section will default to "repository" and "cache" for
-        the repo and cache configs, respectively.
-
-
-        By default, borg config manipulates the repository config file. Using ``--cache``
-        edits the repository cache's config file instead.
-        """
-        )
-        subparser = subparsers.add_parser(
-            "config",
-            parents=[common_parser],
-            add_help=False,
-            description=self.do_config.__doc__,
-            epilog=config_epilog,
-            formatter_class=argparse.RawDescriptionHelpFormatter,
-            help="get and set configuration values",
-        )
-        subparser.set_defaults(func=self.do_config)
-        subparser.add_argument(
-            "-c", "--cache", dest="cache", action="store_true", help="get and set values from the repo cache"
-        )
-
-        group = subparser.add_mutually_exclusive_group()
-        group.add_argument(
-            "-d", "--delete", dest="delete", action="store_true", help="delete the key from the config file"
-        )
-        group.add_argument("-l", "--list", dest="list", action="store_true", help="list the configuration of the repo")
-
-        subparser.add_argument("name", metavar="NAME", nargs="?", help="name of config key")
-        subparser.add_argument("value", metavar="VALUE", nargs="?", help="new value for key")
-
         # borg create
         create_epilog = process_epilog(
             """
@@ -2425,6 +2252,7 @@ class Archiver(DebugMixIn, TarMixIn, BenchmarkMixIn, KeysMixIn, LocksMixIn, Help
         subparser.add_argument("name", metavar="NAME", type=NameSpec, help="specify the archive name")
         subparser.add_argument("paths", metavar="PATH", nargs="*", type=str, help="paths to archive")
 
+        self.build_parser_config(subparsers, common_parser, mid_common_parser)
         self.build_parser_debug(subparsers, common_parser, mid_common_parser)
         self.build_parser_help(subparsers, common_parser, mid_common_parser, parser)
 
diff --git a/src/borg/archiver/config.py b/src/borg/archiver/config.py
new file mode 100644
index 000000000..7e9e85519
--- /dev/null
+++ b/src/borg/archiver/config.py
@@ -0,0 +1,194 @@
+import sys
+import argparse
+import configparser
+from binascii import unhexlify
+
+from .common import with_repository
+from ..cache import Cache, assert_secure
+from ..constants import *  # NOQA
+from ..helpers import EXIT_SUCCESS, EXIT_WARNING
+from ..helpers import Error
+from ..helpers import Location
+from ..helpers import parse_file_size
+from ..helpers import Manifest
+
+from ..logger import create_logger
+
+logger = create_logger()
+
+
+class ConfigMixIn:
+    @with_repository(exclusive=True, manifest=False)
+    def do_config(self, args, repository):
+        """get, set, and delete values in a repository or cache config file"""
+
+        def repo_validate(section, name, value=None, check_value=True):
+            if section not in ["repository"]:
+                raise ValueError("Invalid section")
+            if name in ["segments_per_dir", "last_segment_checked"]:
+                if check_value:
+                    try:
+                        int(value)
+                    except ValueError:
+                        raise ValueError("Invalid value") from None
+            elif name in ["max_segment_size", "additional_free_space", "storage_quota"]:
+                if check_value:
+                    try:
+                        parse_file_size(value)
+                    except ValueError:
+                        raise ValueError("Invalid value") from None
+                    if name == "storage_quota":
+                        if parse_file_size(value) < parse_file_size("10M"):
+                            raise ValueError("Invalid value: storage_quota < 10M")
+                    elif name == "max_segment_size":
+                        if parse_file_size(value) >= MAX_SEGMENT_SIZE_LIMIT:
+                            raise ValueError("Invalid value: max_segment_size >= %d" % MAX_SEGMENT_SIZE_LIMIT)
+            elif name in ["append_only"]:
+                if check_value and value not in ["0", "1"]:
+                    raise ValueError("Invalid value")
+            elif name in ["id"]:
+                if check_value:
+                    try:
+                        bin_id = unhexlify(value)
+                    except:
+                        raise ValueError("Invalid value, must be 64 hex digits") from None
+                    if len(bin_id) != 32:
+                        raise ValueError("Invalid value, must be 64 hex digits")
+            else:
+                raise ValueError("Invalid name")
+
+        def cache_validate(section, name, value=None, check_value=True):
+            if section not in ["cache"]:
+                raise ValueError("Invalid section")
+            if name in ["previous_location"]:
+                if check_value:
+                    Location(value)
+            else:
+                raise ValueError("Invalid name")
+
+        def list_config(config):
+            default_values = {
+                "version": "1",
+                "segments_per_dir": str(DEFAULT_SEGMENTS_PER_DIR),
+                "max_segment_size": str(MAX_SEGMENT_SIZE_LIMIT),
+                "additional_free_space": "0",
+                "storage_quota": repository.storage_quota,
+                "append_only": repository.append_only,
+            }
+            print("[repository]")
+            for key in [
+                "version",
+                "segments_per_dir",
+                "max_segment_size",
+                "storage_quota",
+                "additional_free_space",
+                "append_only",
+                "id",
+            ]:
+                value = config.get("repository", key, fallback=False)
+                if value is None:
+                    value = default_values.get(key)
+                    if value is None:
+                        raise Error("The repository config is missing the %s key which has no default value" % key)
+                print(f"{key} = {value}")
+            for key in ["last_segment_checked"]:
+                value = config.get("repository", key, fallback=None)
+                if value is None:
+                    continue
+                print(f"{key} = {value}")
+
+        if not args.list:
+            if args.name is None:
+                self.print_error("No config key name was provided.")
+                return self.exit_code
+
+            try:
+                section, name = args.name.split(".")
+            except ValueError:
+                section = args.cache and "cache" or "repository"
+                name = args.name
+
+        if args.cache:
+            manifest, key = Manifest.load(repository, (Manifest.Operation.WRITE,))
+            assert_secure(repository, manifest, self.lock_wait)
+            cache = Cache(repository, key, manifest, lock_wait=self.lock_wait)
+
+        try:
+            if args.cache:
+                cache.cache_config.load()
+                config = cache.cache_config._config
+                save = cache.cache_config.save
+                validate = cache_validate
+            else:
+                config = repository.config
+                save = lambda: repository.save_config(repository.path, repository.config)  # noqa
+                validate = repo_validate
+
+            if args.delete:
+                validate(section, name, check_value=False)
+                config.remove_option(section, name)
+                if len(config.options(section)) == 0:
+                    config.remove_section(section)
+                save()
+            elif args.list:
+                list_config(config)
+            elif args.value:
+                validate(section, name, args.value)
+                if section not in config.sections():
+                    config.add_section(section)
+                config.set(section, name, args.value)
+                save()
+            else:
+                try:
+                    print(config.get(section, name))
+                except (configparser.NoOptionError, configparser.NoSectionError) as e:
+                    print(e, file=sys.stderr)
+                    return EXIT_WARNING
+            return EXIT_SUCCESS
+        finally:
+            if args.cache:
+                cache.close()
+
+    def build_parser_config(self, subparsers, common_parser, mid_common_parser):
+
+        from .common import process_epilog
+
+        config_epilog = process_epilog(
+            """
+        This command gets and sets options in a local repository or cache config file.
+        For security reasons, this command only works on local repositories.
+
+        To delete a config value entirely, use ``--delete``. To list the values
+        of the configuration file or the default values, use ``--list``.  To get and existing
+        key, pass only the key name. To set a key, pass both the key name and
+        the new value. Keys can be specified in the format "section.name" or
+        simply "name"; the section will default to "repository" and "cache" for
+        the repo and cache configs, respectively.
+
+
+        By default, borg config manipulates the repository config file. Using ``--cache``
+        edits the repository cache's config file instead.
+        """
+        )
+        subparser = subparsers.add_parser(
+            "config",
+            parents=[common_parser],
+            add_help=False,
+            description=self.do_config.__doc__,
+            epilog=config_epilog,
+            formatter_class=argparse.RawDescriptionHelpFormatter,
+            help="get and set configuration values",
+        )
+        subparser.set_defaults(func=self.do_config)
+        subparser.add_argument(
+            "-c", "--cache", dest="cache", action="store_true", help="get and set values from the repo cache"
+        )
+
+        group = subparser.add_mutually_exclusive_group()
+        group.add_argument(
+            "-d", "--delete", dest="delete", action="store_true", help="delete the key from the config file"
+        )
+        group.add_argument("-l", "--list", dest="list", action="store_true", help="list the configuration of the repo")
+
+        subparser.add_argument("name", metavar="NAME", nargs="?", help="name of config key")
+        subparser.add_argument("value", metavar="VALUE", nargs="?", help="new value for key")

From ea03562b11dea2401e3c770384874e3fcb7bd783 Mon Sep 17 00:00:00 2001
From: Thomas Waldmann <tw@waldmann-edv.de>
Date: Fri, 8 Jul 2022 22:09:26 +0200
Subject: [PATCH 126/160] move prune command to archiver.prune

---
 setup.cfg                     |   1 +
 src/borg/archiver/__init__.py | 214 +------------------------------
 src/borg/archiver/prune.py    | 229 ++++++++++++++++++++++++++++++++++
 3 files changed, 235 insertions(+), 209 deletions(-)
 create mode 100644 src/borg/archiver/prune.py

diff --git a/setup.cfg b/setup.cfg
index dd9230179..60975408d 100644
--- a/setup.cfg
+++ b/setup.cfg
@@ -123,6 +123,7 @@ per_file_ignores =
     src/borg/archiver/debug.py:F405
     src/borg/archiver/help.py:E501,F405
     src/borg/archiver/keys.py:F405
+    src/borg/archiver/prune.py:F405
     src/borg/archiver/tar.py:F405
     src/borg/cache.py:E127,E128,E402,E501,E722,W504
     src/borg/fuse.py:E402,E501,E722,W504
diff --git a/src/borg/archiver/__init__.py b/src/borg/archiver/__init__.py
index 45e3702da..5f170283c 100644
--- a/src/borg/archiver/__init__.py
+++ b/src/borg/archiver/__init__.py
@@ -12,7 +12,6 @@ try:
     import json
     import logging
     import os
-    import re
     import shlex
     import signal
     import stat
@@ -43,7 +42,6 @@ try:
     from ..helpers import BaseFormatter, ItemFormatter, ArchiveFormatter
     from ..helpers import format_timedelta, format_file_size, parse_file_size, format_archive
     from ..helpers import remove_surrogates, bin_to_hex, eval_escapes
-    from ..helpers import interval, prune_within, prune_split, PRUNING_PATTERNS
     from ..helpers import timestamp
     from ..helpers import get_cache_dir, os_stat
     from ..helpers import Manifest
@@ -105,11 +103,14 @@ from .debug import DebugMixIn
 from .help import HelpMixIn
 from .keys import KeysMixIn
 from .locks import LocksMixIn
+from .prune import PruneMixIn
 from .tar import TarMixIn
 from .transfer import TransferMixIn
 
 
-class Archiver(ConfigMixIn, DebugMixIn, TarMixIn, BenchmarkMixIn, KeysMixIn, LocksMixIn, HelpMixIn, TransferMixIn):
+class Archiver(
+    ConfigMixIn, DebugMixIn, TarMixIn, BenchmarkMixIn, KeysMixIn, LocksMixIn, PruneMixIn, HelpMixIn, TransferMixIn
+):
     def __init__(self, lock_wait=None, prog=None):
         self.exit_code = EXIT_SUCCESS
         self.lock_wait = lock_wait
@@ -1164,93 +1165,6 @@ class Archiver(ConfigMixIn, DebugMixIn, TarMixIn, BenchmarkMixIn, KeysMixIn, Loc
             json_print(basic_json_data(manifest, cache=cache, extra={"archives": output_data}))
         return self.exit_code
 
-    @with_repository(exclusive=True, compatibility=(Manifest.Operation.DELETE,))
-    def do_prune(self, args, repository, manifest, key):
-        """Prune repository archives according to specified rules"""
-        if not any(
-            (args.secondly, args.minutely, args.hourly, args.daily, args.weekly, args.monthly, args.yearly, args.within)
-        ):
-            self.print_error(
-                'At least one of the "keep-within", "keep-last", '
-                '"keep-secondly", "keep-minutely", "keep-hourly", "keep-daily", '
-                '"keep-weekly", "keep-monthly" or "keep-yearly" settings must be specified.'
-            )
-            return self.exit_code
-        checkpoint_re = r"\.checkpoint(\.\d+)?"
-        archives_checkpoints = manifest.archives.list(
-            glob=args.glob_archives,
-            consider_checkpoints=True,
-            match_end=r"(%s)?\Z" % checkpoint_re,
-            sort_by=["ts"],
-            reverse=True,
-        )
-        is_checkpoint = re.compile(r"(%s)\Z" % checkpoint_re).search
-        checkpoints = [arch for arch in archives_checkpoints if is_checkpoint(arch.name)]
-        # keep the latest checkpoint, if there is no later non-checkpoint archive
-        if archives_checkpoints and checkpoints and archives_checkpoints[0] is checkpoints[0]:
-            keep_checkpoints = checkpoints[:1]
-        else:
-            keep_checkpoints = []
-        checkpoints = set(checkpoints)
-        # ignore all checkpoint archives to avoid keeping one (which is an incomplete backup)
-        # that is newer than a successfully completed backup - and killing the successful backup.
-        archives = [arch for arch in archives_checkpoints if arch not in checkpoints]
-        keep = []
-        # collect the rule responsible for the keeping of each archive in this dict
-        # keys are archive ids, values are a tuple
-        #   (<rulename>, <how many archives were kept by this rule so far >)
-        kept_because = {}
-
-        # find archives which need to be kept because of the keep-within rule
-        if args.within:
-            keep += prune_within(archives, args.within, kept_because)
-
-        # find archives which need to be kept because of the various time period rules
-        for rule in PRUNING_PATTERNS.keys():
-            num = getattr(args, rule, None)
-            if num is not None:
-                keep += prune_split(archives, rule, num, kept_because)
-
-        to_delete = (set(archives) | checkpoints) - (set(keep) | set(keep_checkpoints))
-        stats = Statistics(iec=args.iec)
-        with Cache(repository, key, manifest, lock_wait=self.lock_wait, iec=args.iec) as cache:
-            list_logger = logging.getLogger("borg.output.list")
-            # set up counters for the progress display
-            to_delete_len = len(to_delete)
-            archives_deleted = 0
-            pi = ProgressIndicatorPercent(total=len(to_delete), msg="Pruning archives %3.0f%%", msgid="prune")
-            for archive in archives_checkpoints:
-                if archive in to_delete:
-                    pi.show()
-                    if args.dry_run:
-                        log_message = "Would prune:"
-                    else:
-                        archives_deleted += 1
-                        log_message = "Pruning archive (%d/%d):" % (archives_deleted, to_delete_len)
-                        archive = Archive(
-                            repository, key, manifest, archive.name, cache, consider_part_files=args.consider_part_files
-                        )
-                        archive.delete(stats, forced=args.forced)
-                else:
-                    if is_checkpoint(archive.name):
-                        log_message = "Keeping checkpoint archive:"
-                    else:
-                        log_message = "Keeping archive (rule: {rule} #{num}):".format(
-                            rule=kept_because[archive.id][0], num=kept_because[archive.id][1]
-                        )
-                if args.output_list:
-                    list_logger.info(
-                        "{message:<40} {archive}".format(message=log_message, archive=format_archive(archive))
-                    )
-            pi.finish()
-            if to_delete and not args.dry_run:
-                manifest.write()
-                repository.commit(compact=False, save_space=args.save_space)
-                cache.commit()
-            if args.stats:
-                log_multi(str(stats), logger=logging.getLogger("borg.output.stats"))
-        return self.exit_code
-
     @with_repository(cache=True, exclusive=True, compatibility=(Manifest.Operation.CHECK,))
     def do_recreate(self, args, repository, manifest, key, cache):
         """Re-create archives"""
@@ -1714,6 +1628,7 @@ class Archiver(ConfigMixIn, DebugMixIn, TarMixIn, BenchmarkMixIn, KeysMixIn, Loc
 
         self.build_parser_benchmarks(subparsers, common_parser, mid_common_parser)
         self.build_parser_locks(subparsers, common_parser, mid_common_parser)
+        self.build_parser_prune(subparsers, common_parser, mid_common_parser)
 
         # borg check
         check_epilog = process_epilog(
@@ -2888,125 +2803,6 @@ class Archiver(ConfigMixIn, DebugMixIn, TarMixIn, BenchmarkMixIn, KeysMixIn, Loc
         )
         define_borg_mount(subparser)
 
-        # borg prune
-        prune_epilog = process_epilog(
-            """
-        The prune command prunes a repository by deleting all archives not matching
-        any of the specified retention options.
-
-        Important: Repository disk space is **not** freed until you run ``borg compact``.
-
-        This command is normally used by automated backup scripts wanting to keep a
-        certain number of historic backups. This retention policy is commonly referred to as
-        `GFS <https://en.wikipedia.org/wiki/Backup_rotation_scheme#Grandfather-father-son>`_
-        (Grandfather-father-son) backup rotation scheme.
-
-        Also, prune automatically removes checkpoint archives (incomplete archives left
-        behind by interrupted backup runs) except if the checkpoint is the latest
-        archive (and thus still needed). Checkpoint archives are not considered when
-        comparing archive counts against the retention limits (``--keep-X``).
-
-        If a prefix is set with -P, then only archives that start with the prefix are
-        considered for deletion and only those archives count towards the totals
-        specified by the rules.
-        Otherwise, *all* archives in the repository are candidates for deletion!
-        There is no automatic distinction between archives representing different
-        contents. These need to be distinguished by specifying matching prefixes.
-
-        If you have multiple sequences of archives with different data sets (e.g.
-        from different machines) in one shared repository, use one prune call per
-        data set that matches only the respective archives using the -P option.
-
-        The ``--keep-within`` option takes an argument of the form "<int><char>",
-        where char is "H", "d", "w", "m", "y". For example, ``--keep-within 2d`` means
-        to keep all archives that were created within the past 48 hours.
-        "1m" is taken to mean "31d". The archives kept with this option do not
-        count towards the totals specified by any other options.
-
-        A good procedure is to thin out more and more the older your backups get.
-        As an example, ``--keep-daily 7`` means to keep the latest backup on each day,
-        up to 7 most recent days with backups (days without backups do not count).
-        The rules are applied from secondly to yearly, and backups selected by previous
-        rules do not count towards those of later rules. The time that each backup
-        starts is used for pruning purposes. Dates and times are interpreted in
-        the local timezone, and weeks go from Monday to Sunday. Specifying a
-        negative number of archives to keep means that there is no limit. As of borg
-        1.2.0, borg will retain the oldest archive if any of the secondly, minutely,
-        hourly, daily, weekly, monthly, or yearly rules was not otherwise able to meet
-        its retention target. This enables the first chronological archive to continue
-        aging until it is replaced by a newer archive that meets the retention criteria.
-
-        The ``--keep-last N`` option is doing the same as ``--keep-secondly N`` (and it will
-        keep the last N archives under the assumption that you do not create more than one
-        backup archive in the same second).
-
-        When using ``--stats``, you will get some statistics about how much data was
-        deleted - the "Deleted data" deduplicated size there is most interesting as
-        that is how much your repository will shrink.
-        Please note that the "All archives" stats refer to the state after pruning.
-        """
-        )
-        subparser = subparsers.add_parser(
-            "prune",
-            parents=[common_parser],
-            add_help=False,
-            description=self.do_prune.__doc__,
-            epilog=prune_epilog,
-            formatter_class=argparse.RawDescriptionHelpFormatter,
-            help="prune archives",
-        )
-        subparser.set_defaults(func=self.do_prune)
-        subparser.add_argument("-n", "--dry-run", dest="dry_run", action="store_true", help="do not change repository")
-        subparser.add_argument(
-            "--force",
-            dest="forced",
-            action="store_true",
-            help="force pruning of corrupted archives, " "use ``--force --force`` in case ``--force`` does not work.",
-        )
-        subparser.add_argument(
-            "-s", "--stats", dest="stats", action="store_true", help="print statistics for the deleted archive"
-        )
-        subparser.add_argument(
-            "--list", dest="output_list", action="store_true", help="output verbose list of archives it keeps/prunes"
-        )
-        subparser.add_argument(
-            "--keep-within",
-            metavar="INTERVAL",
-            dest="within",
-            type=interval,
-            help="keep all archives within this time interval",
-        )
-        subparser.add_argument(
-            "--keep-last",
-            "--keep-secondly",
-            dest="secondly",
-            type=int,
-            default=0,
-            help="number of secondly archives to keep",
-        )
-        subparser.add_argument(
-            "--keep-minutely", dest="minutely", type=int, default=0, help="number of minutely archives to keep"
-        )
-        subparser.add_argument(
-            "-H", "--keep-hourly", dest="hourly", type=int, default=0, help="number of hourly archives to keep"
-        )
-        subparser.add_argument(
-            "-d", "--keep-daily", dest="daily", type=int, default=0, help="number of daily archives to keep"
-        )
-        subparser.add_argument(
-            "-w", "--keep-weekly", dest="weekly", type=int, default=0, help="number of weekly archives to keep"
-        )
-        subparser.add_argument(
-            "-m", "--keep-monthly", dest="monthly", type=int, default=0, help="number of monthly archives to keep"
-        )
-        subparser.add_argument(
-            "-y", "--keep-yearly", dest="yearly", type=int, default=0, help="number of yearly archives to keep"
-        )
-        define_archive_filters_group(subparser, sort_by=False, first_last=False)
-        subparser.add_argument(
-            "--save-space", dest="save_space", action="store_true", help="work slower, but using less space"
-        )
-
         # borg recreate
         recreate_epilog = process_epilog(
             """
diff --git a/src/borg/archiver/prune.py b/src/borg/archiver/prune.py
new file mode 100644
index 000000000..1015f4d96
--- /dev/null
+++ b/src/borg/archiver/prune.py
@@ -0,0 +1,229 @@
+import argparse
+import logging
+import re
+
+from .common import with_repository
+from ..archive import Archive, Statistics
+from ..cache import Cache
+from ..constants import *  # NOQA
+from ..helpers import format_archive
+from ..helpers import interval, prune_within, prune_split, PRUNING_PATTERNS
+from ..helpers import Manifest
+from ..helpers import log_multi
+from ..helpers import ProgressIndicatorPercent
+
+from ..logger import create_logger
+
+logger = create_logger()
+
+
+class PruneMixIn:
+    @with_repository(exclusive=True, compatibility=(Manifest.Operation.DELETE,))
+    def do_prune(self, args, repository, manifest, key):
+        """Prune repository archives according to specified rules"""
+        if not any(
+            (args.secondly, args.minutely, args.hourly, args.daily, args.weekly, args.monthly, args.yearly, args.within)
+        ):
+            self.print_error(
+                'At least one of the "keep-within", "keep-last", '
+                '"keep-secondly", "keep-minutely", "keep-hourly", "keep-daily", '
+                '"keep-weekly", "keep-monthly" or "keep-yearly" settings must be specified.'
+            )
+            return self.exit_code
+        checkpoint_re = r"\.checkpoint(\.\d+)?"
+        archives_checkpoints = manifest.archives.list(
+            glob=args.glob_archives,
+            consider_checkpoints=True,
+            match_end=r"(%s)?\Z" % checkpoint_re,
+            sort_by=["ts"],
+            reverse=True,
+        )
+        is_checkpoint = re.compile(r"(%s)\Z" % checkpoint_re).search
+        checkpoints = [arch for arch in archives_checkpoints if is_checkpoint(arch.name)]
+        # keep the latest checkpoint, if there is no later non-checkpoint archive
+        if archives_checkpoints and checkpoints and archives_checkpoints[0] is checkpoints[0]:
+            keep_checkpoints = checkpoints[:1]
+        else:
+            keep_checkpoints = []
+        checkpoints = set(checkpoints)
+        # ignore all checkpoint archives to avoid keeping one (which is an incomplete backup)
+        # that is newer than a successfully completed backup - and killing the successful backup.
+        archives = [arch for arch in archives_checkpoints if arch not in checkpoints]
+        keep = []
+        # collect the rule responsible for the keeping of each archive in this dict
+        # keys are archive ids, values are a tuple
+        #   (<rulename>, <how many archives were kept by this rule so far >)
+        kept_because = {}
+
+        # find archives which need to be kept because of the keep-within rule
+        if args.within:
+            keep += prune_within(archives, args.within, kept_because)
+
+        # find archives which need to be kept because of the various time period rules
+        for rule in PRUNING_PATTERNS.keys():
+            num = getattr(args, rule, None)
+            if num is not None:
+                keep += prune_split(archives, rule, num, kept_because)
+
+        to_delete = (set(archives) | checkpoints) - (set(keep) | set(keep_checkpoints))
+        stats = Statistics(iec=args.iec)
+        with Cache(repository, key, manifest, lock_wait=self.lock_wait, iec=args.iec) as cache:
+            list_logger = logging.getLogger("borg.output.list")
+            # set up counters for the progress display
+            to_delete_len = len(to_delete)
+            archives_deleted = 0
+            pi = ProgressIndicatorPercent(total=len(to_delete), msg="Pruning archives %3.0f%%", msgid="prune")
+            for archive in archives_checkpoints:
+                if archive in to_delete:
+                    pi.show()
+                    if args.dry_run:
+                        log_message = "Would prune:"
+                    else:
+                        archives_deleted += 1
+                        log_message = "Pruning archive (%d/%d):" % (archives_deleted, to_delete_len)
+                        archive = Archive(
+                            repository, key, manifest, archive.name, cache, consider_part_files=args.consider_part_files
+                        )
+                        archive.delete(stats, forced=args.forced)
+                else:
+                    if is_checkpoint(archive.name):
+                        log_message = "Keeping checkpoint archive:"
+                    else:
+                        log_message = "Keeping archive (rule: {rule} #{num}):".format(
+                            rule=kept_because[archive.id][0], num=kept_because[archive.id][1]
+                        )
+                if args.output_list:
+                    list_logger.info(
+                        "{message:<40} {archive}".format(message=log_message, archive=format_archive(archive))
+                    )
+            pi.finish()
+            if to_delete and not args.dry_run:
+                manifest.write()
+                repository.commit(compact=False, save_space=args.save_space)
+                cache.commit()
+            if args.stats:
+                log_multi(str(stats), logger=logging.getLogger("borg.output.stats"))
+        return self.exit_code
+
+    def build_parser_prune(self, subparsers, common_parser, mid_common_parser):
+
+        from .common import process_epilog
+        from .common import define_archive_filters_group
+
+        prune_epilog = process_epilog(
+            """
+        The prune command prunes a repository by deleting all archives not matching
+        any of the specified retention options.
+
+        Important: Repository disk space is **not** freed until you run ``borg compact``.
+
+        This command is normally used by automated backup scripts wanting to keep a
+        certain number of historic backups. This retention policy is commonly referred to as
+        `GFS <https://en.wikipedia.org/wiki/Backup_rotation_scheme#Grandfather-father-son>`_
+        (Grandfather-father-son) backup rotation scheme.
+
+        Also, prune automatically removes checkpoint archives (incomplete archives left
+        behind by interrupted backup runs) except if the checkpoint is the latest
+        archive (and thus still needed). Checkpoint archives are not considered when
+        comparing archive counts against the retention limits (``--keep-X``).
+
+        If a prefix is set with -P, then only archives that start with the prefix are
+        considered for deletion and only those archives count towards the totals
+        specified by the rules.
+        Otherwise, *all* archives in the repository are candidates for deletion!
+        There is no automatic distinction between archives representing different
+        contents. These need to be distinguished by specifying matching prefixes.
+
+        If you have multiple sequences of archives with different data sets (e.g.
+        from different machines) in one shared repository, use one prune call per
+        data set that matches only the respective archives using the -P option.
+
+        The ``--keep-within`` option takes an argument of the form "<int><char>",
+        where char is "H", "d", "w", "m", "y". For example, ``--keep-within 2d`` means
+        to keep all archives that were created within the past 48 hours.
+        "1m" is taken to mean "31d". The archives kept with this option do not
+        count towards the totals specified by any other options.
+
+        A good procedure is to thin out more and more the older your backups get.
+        As an example, ``--keep-daily 7`` means to keep the latest backup on each day,
+        up to 7 most recent days with backups (days without backups do not count).
+        The rules are applied from secondly to yearly, and backups selected by previous
+        rules do not count towards those of later rules. The time that each backup
+        starts is used for pruning purposes. Dates and times are interpreted in
+        the local timezone, and weeks go from Monday to Sunday. Specifying a
+        negative number of archives to keep means that there is no limit. As of borg
+        1.2.0, borg will retain the oldest archive if any of the secondly, minutely,
+        hourly, daily, weekly, monthly, or yearly rules was not otherwise able to meet
+        its retention target. This enables the first chronological archive to continue
+        aging until it is replaced by a newer archive that meets the retention criteria.
+
+        The ``--keep-last N`` option is doing the same as ``--keep-secondly N`` (and it will
+        keep the last N archives under the assumption that you do not create more than one
+        backup archive in the same second).
+
+        When using ``--stats``, you will get some statistics about how much data was
+        deleted - the "Deleted data" deduplicated size there is most interesting as
+        that is how much your repository will shrink.
+        Please note that the "All archives" stats refer to the state after pruning.
+        """
+        )
+        subparser = subparsers.add_parser(
+            "prune",
+            parents=[common_parser],
+            add_help=False,
+            description=self.do_prune.__doc__,
+            epilog=prune_epilog,
+            formatter_class=argparse.RawDescriptionHelpFormatter,
+            help="prune archives",
+        )
+        subparser.set_defaults(func=self.do_prune)
+        subparser.add_argument("-n", "--dry-run", dest="dry_run", action="store_true", help="do not change repository")
+        subparser.add_argument(
+            "--force",
+            dest="forced",
+            action="store_true",
+            help="force pruning of corrupted archives, " "use ``--force --force`` in case ``--force`` does not work.",
+        )
+        subparser.add_argument(
+            "-s", "--stats", dest="stats", action="store_true", help="print statistics for the deleted archive"
+        )
+        subparser.add_argument(
+            "--list", dest="output_list", action="store_true", help="output verbose list of archives it keeps/prunes"
+        )
+        subparser.add_argument(
+            "--keep-within",
+            metavar="INTERVAL",
+            dest="within",
+            type=interval,
+            help="keep all archives within this time interval",
+        )
+        subparser.add_argument(
+            "--keep-last",
+            "--keep-secondly",
+            dest="secondly",
+            type=int,
+            default=0,
+            help="number of secondly archives to keep",
+        )
+        subparser.add_argument(
+            "--keep-minutely", dest="minutely", type=int, default=0, help="number of minutely archives to keep"
+        )
+        subparser.add_argument(
+            "-H", "--keep-hourly", dest="hourly", type=int, default=0, help="number of hourly archives to keep"
+        )
+        subparser.add_argument(
+            "-d", "--keep-daily", dest="daily", type=int, default=0, help="number of daily archives to keep"
+        )
+        subparser.add_argument(
+            "-w", "--keep-weekly", dest="weekly", type=int, default=0, help="number of weekly archives to keep"
+        )
+        subparser.add_argument(
+            "-m", "--keep-monthly", dest="monthly", type=int, default=0, help="number of monthly archives to keep"
+        )
+        subparser.add_argument(
+            "-y", "--keep-yearly", dest="yearly", type=int, default=0, help="number of yearly archives to keep"
+        )
+        define_archive_filters_group(subparser, sort_by=False, first_last=False)
+        subparser.add_argument(
+            "--save-space", dest="save_space", action="store_true", help="work slower, but using less space"
+        )

From 9fb224db6b2c45c2c9a3fb760ff39968e45127b6 Mon Sep 17 00:00:00 2001
From: Thomas Waldmann <tw@waldmann-edv.de>
Date: Fri, 8 Jul 2022 22:27:48 +0200
Subject: [PATCH 127/160] move diff command to archiver.diff

---
 setup.cfg                     |   1 +
 src/borg/archiver/__init__.py | 113 ++++----------------------------
 src/borg/archiver/diff.py     | 118 ++++++++++++++++++++++++++++++++++
 3 files changed, 131 insertions(+), 101 deletions(-)
 create mode 100644 src/borg/archiver/diff.py

diff --git a/setup.cfg b/setup.cfg
index 60975408d..5c78cde38 100644
--- a/setup.cfg
+++ b/setup.cfg
@@ -121,6 +121,7 @@ per_file_ignores =
     src/borg/archiver/config.py:F405,E722
     src/borg/archiver/common.py:E501,F405
     src/borg/archiver/debug.py:F405
+    src/borg/archiver/diff.py:F405
     src/borg/archiver/help.py:E501,F405
     src/borg/archiver/keys.py:F405
     src/borg/archiver/prune.py:F405
diff --git a/src/borg/archiver/__init__.py b/src/borg/archiver/__init__.py
index 5f170283c..1e12de7f5 100644
--- a/src/borg/archiver/__init__.py
+++ b/src/borg/archiver/__init__.py
@@ -100,6 +100,7 @@ def get_func(args):
 from .benchmarks import BenchmarkMixIn
 from .config import ConfigMixIn
 from .debug import DebugMixIn
+from .diff import DiffMixIn
 from .help import HelpMixIn
 from .keys import KeysMixIn
 from .locks import LocksMixIn
@@ -109,7 +110,16 @@ from .transfer import TransferMixIn
 
 
 class Archiver(
-    ConfigMixIn, DebugMixIn, TarMixIn, BenchmarkMixIn, KeysMixIn, LocksMixIn, PruneMixIn, HelpMixIn, TransferMixIn
+    ConfigMixIn,
+    DebugMixIn,
+    DiffMixIn,
+    TarMixIn,
+    BenchmarkMixIn,
+    KeysMixIn,
+    LocksMixIn,
+    PruneMixIn,
+    HelpMixIn,
+    TransferMixIn,
 ):
     def __init__(self, lock_wait=None, prog=None):
         self.exit_code = EXIT_SUCCESS
@@ -774,50 +784,6 @@ class Archiver(
             pi.finish()
         return self.exit_code
 
-    @with_repository(compatibility=(Manifest.Operation.READ,))
-    @with_archive
-    def do_diff(self, args, repository, manifest, key, archive):
-        """Diff contents of two archives"""
-
-        def print_json_output(diff, path):
-            print(json.dumps({"path": path, "changes": [j for j, str in diff]}))
-
-        def print_text_output(diff, path):
-            print("{:<19} {}".format(" ".join([str for j, str in diff]), path))
-
-        print_output = print_json_output if args.json_lines else print_text_output
-
-        archive1 = archive
-        archive2 = Archive(repository, key, manifest, args.other_name, consider_part_files=args.consider_part_files)
-
-        can_compare_chunk_ids = (
-            archive1.metadata.get("chunker_params", False) == archive2.metadata.get("chunker_params", True)
-            or args.same_chunker_params
-        )
-        if not can_compare_chunk_ids:
-            self.print_warning(
-                "--chunker-params might be different between archives, diff will be slow.\n"
-                "If you know for certain that they are the same, pass --same-chunker-params "
-                "to override this check."
-            )
-
-        matcher = self.build_matcher(args.patterns, args.paths)
-
-        diffs = Archive.compare_archives_iter(archive1, archive2, matcher, can_compare_chunk_ids=can_compare_chunk_ids)
-        # Conversion to string and filtering for diff.equal to save memory if sorting
-        diffs = ((path, diff.changes()) for path, diff in diffs if not diff.equal)
-
-        if args.sort:
-            diffs = sorted(diffs)
-
-        for path, diff in diffs:
-            print_output(diff, path)
-
-        for pattern in matcher.get_unmatched_include_patterns():
-            self.print_warning("Include pattern '%s' never matched.", pattern)
-
-        return self.exit_code
-
     @with_repository(exclusive=True, cache=True, compatibility=(Manifest.Operation.CHECK,))
     @with_archive
     def do_rename(self, args, repository, manifest, key, cache, archive):
@@ -1627,6 +1593,7 @@ class Archiver(
         subparsers = parser.add_subparsers(title="required arguments", metavar="<command>")
 
         self.build_parser_benchmarks(subparsers, common_parser, mid_common_parser)
+        self.build_parser_diff(subparsers, common_parser, mid_common_parser)
         self.build_parser_locks(subparsers, common_parser, mid_common_parser)
         self.build_parser_prune(subparsers, common_parser, mid_common_parser)
 
@@ -2287,62 +2254,6 @@ class Archiver(
         )
         define_archive_filters_group(subparser)
 
-        # borg diff
-        diff_epilog = process_epilog(
-            """
-            This command finds differences (file contents, user/group/mode) between archives.
-
-            A repository location and an archive name must be specified for REPO::ARCHIVE1.
-            ARCHIVE2 is just another archive name in same repository (no repository location
-            allowed).
-
-            For archives created with Borg 1.1 or newer diff automatically detects whether
-            the archives are created with the same chunker params. If so, only chunk IDs
-            are compared, which is very fast.
-
-            For archives prior to Borg 1.1 chunk contents are compared by default.
-            If you did not create the archives with different chunker params,
-            pass ``--same-chunker-params``.
-            Note that the chunker params changed from Borg 0.xx to 1.0.
-
-            For more help on include/exclude patterns, see the :ref:`borg_patterns` command output.
-            """
-        )
-        subparser = subparsers.add_parser(
-            "diff",
-            parents=[common_parser],
-            add_help=False,
-            description=self.do_diff.__doc__,
-            epilog=diff_epilog,
-            formatter_class=argparse.RawDescriptionHelpFormatter,
-            help="find differences in archive contents",
-        )
-        subparser.set_defaults(func=self.do_diff)
-        subparser.add_argument(
-            "--numeric-ids",
-            dest="numeric_ids",
-            action="store_true",
-            help="only consider numeric user and group identifiers",
-        )
-        subparser.add_argument(
-            "--same-chunker-params",
-            dest="same_chunker_params",
-            action="store_true",
-            help="Override check of chunker parameters.",
-        )
-        subparser.add_argument("--sort", dest="sort", action="store_true", help="Sort the output lines by file path.")
-        subparser.add_argument("--json-lines", action="store_true", help="Format output as JSON Lines. ")
-        subparser.add_argument("name", metavar="ARCHIVE1", type=archivename_validator(), help="ARCHIVE1 name")
-        subparser.add_argument("other_name", metavar="ARCHIVE2", type=archivename_validator(), help="ARCHIVE2 name")
-        subparser.add_argument(
-            "paths",
-            metavar="PATH",
-            nargs="*",
-            type=str,
-            help="paths of items inside the archives to compare; patterns are supported",
-        )
-        define_exclusion_group(subparser)
-
         # borg extract
         extract_epilog = process_epilog(
             """
diff --git a/src/borg/archiver/diff.py b/src/borg/archiver/diff.py
new file mode 100644
index 000000000..d06ebe0f5
--- /dev/null
+++ b/src/borg/archiver/diff.py
@@ -0,0 +1,118 @@
+import argparse
+import json
+
+from .common import with_repository, with_archive
+from ..archive import Archive
+from ..constants import *  # NOQA
+from ..helpers import archivename_validator
+from ..helpers import Manifest
+
+from ..logger import create_logger
+
+logger = create_logger()
+
+
+class DiffMixIn:
+    @with_repository(compatibility=(Manifest.Operation.READ,))
+    @with_archive
+    def do_diff(self, args, repository, manifest, key, archive):
+        """Diff contents of two archives"""
+
+        def print_json_output(diff, path):
+            print(json.dumps({"path": path, "changes": [j for j, str in diff]}))
+
+        def print_text_output(diff, path):
+            print("{:<19} {}".format(" ".join([str for j, str in diff]), path))
+
+        print_output = print_json_output if args.json_lines else print_text_output
+
+        archive1 = archive
+        archive2 = Archive(repository, key, manifest, args.other_name, consider_part_files=args.consider_part_files)
+
+        can_compare_chunk_ids = (
+            archive1.metadata.get("chunker_params", False) == archive2.metadata.get("chunker_params", True)
+            or args.same_chunker_params
+        )
+        if not can_compare_chunk_ids:
+            self.print_warning(
+                "--chunker-params might be different between archives, diff will be slow.\n"
+                "If you know for certain that they are the same, pass --same-chunker-params "
+                "to override this check."
+            )
+
+        matcher = self.build_matcher(args.patterns, args.paths)
+
+        diffs = Archive.compare_archives_iter(archive1, archive2, matcher, can_compare_chunk_ids=can_compare_chunk_ids)
+        # Conversion to string and filtering for diff.equal to save memory if sorting
+        diffs = ((path, diff.changes()) for path, diff in diffs if not diff.equal)
+
+        if args.sort:
+            diffs = sorted(diffs)
+
+        for path, diff in diffs:
+            print_output(diff, path)
+
+        for pattern in matcher.get_unmatched_include_patterns():
+            self.print_warning("Include pattern '%s' never matched.", pattern)
+
+        return self.exit_code
+
+    def build_parser_diff(self, subparsers, common_parser, mid_common_parser):
+
+        from .common import process_epilog
+        from .common import define_exclusion_group
+
+        diff_epilog = process_epilog(
+            """
+            This command finds differences (file contents, user/group/mode) between archives.
+
+            A repository location and an archive name must be specified for REPO::ARCHIVE1.
+            ARCHIVE2 is just another archive name in same repository (no repository location
+            allowed).
+
+            For archives created with Borg 1.1 or newer diff automatically detects whether
+            the archives are created with the same chunker params. If so, only chunk IDs
+            are compared, which is very fast.
+
+            For archives prior to Borg 1.1 chunk contents are compared by default.
+            If you did not create the archives with different chunker params,
+            pass ``--same-chunker-params``.
+            Note that the chunker params changed from Borg 0.xx to 1.0.
+
+            For more help on include/exclude patterns, see the :ref:`borg_patterns` command output.
+            """
+        )
+        subparser = subparsers.add_parser(
+            "diff",
+            parents=[common_parser],
+            add_help=False,
+            description=self.do_diff.__doc__,
+            epilog=diff_epilog,
+            formatter_class=argparse.RawDescriptionHelpFormatter,
+            help="find differences in archive contents",
+        )
+        subparser.set_defaults(func=self.do_diff)
+        subparser.add_argument(
+            "--numeric-ids",
+            dest="numeric_ids",
+            action="store_true",
+            help="only consider numeric user and group identifiers",
+        )
+        subparser.add_argument(
+            "--same-chunker-params",
+            dest="same_chunker_params",
+            action="store_true",
+            help="Override check of chunker parameters.",
+        )
+        subparser.add_argument("--sort", dest="sort", action="store_true", help="Sort the output lines by file path.")
+        subparser.add_argument("--json-lines", action="store_true", help="Format output as JSON Lines. ")
+        subparser.add_argument("name", metavar="ARCHIVE1", type=archivename_validator(), help="ARCHIVE1 name")
+        subparser.add_argument("other_name", metavar="ARCHIVE2", type=archivename_validator(), help="ARCHIVE2 name")
+        subparser.add_argument(
+            "paths",
+            metavar="PATH",
+            nargs="*",
+            type=str,
+            help="paths of items inside the archives to compare; patterns are supported",
+        )
+        define_exclusion_group(subparser)

From df57d33b5f5cb7f9c5b3f45281c40d3ff4f8e74a Mon Sep 17 00:00:00 2001
From: Thomas Waldmann <tw@waldmann-edv.de>
Date: Fri, 8 Jul 2022 22:38:56 +0200
Subject: [PATCH 128/160] move compact command to archiver.compact

---
 src/borg/archiver/__init__.py | 54 ++--------------------------
 src/borg/archiver/compact.py  | 66 +++++++++++++++++++++++++++++++++++
 2 files changed, 69 insertions(+), 51 deletions(-)
 create mode 100644 src/borg/archiver/compact.py

diff --git a/src/borg/archiver/__init__.py b/src/borg/archiver/__init__.py
index 1e12de7f5..29759f4fd 100644
--- a/src/borg/archiver/__init__.py
+++ b/src/borg/archiver/__init__.py
@@ -98,6 +98,7 @@ def get_func(args):
 
 
 from .benchmarks import BenchmarkMixIn
+from .compact import CompactMixIn
 from .config import ConfigMixIn
 from .debug import DebugMixIn
 from .diff import DiffMixIn
@@ -111,6 +112,7 @@ from .transfer import TransferMixIn
 
 class Archiver(
     ConfigMixIn,
+    CompactMixIn,
     DebugMixIn,
     DiffMixIn,
     TarMixIn,
@@ -1177,16 +1179,6 @@ class Archiver(
             cache.commit()
         return self.exit_code
 
-    @with_repository(manifest=False, exclusive=True)
-    def do_compact(self, args, repository):
-        """compact segment files in the repository"""
-        # see the comment in do_with_lock about why we do it like this:
-        data = repository.get(Manifest.MANIFEST_ID)
-        repository.put(Manifest.MANIFEST_ID, data)
-        threshold = args.threshold / 100
-        repository.commit(compact=True, threshold=threshold)
-        return EXIT_SUCCESS
-
     def preprocess_args(self, args):
         deprecations = [
             # ('--old', '--new' or None, 'Warning: "--old" has been deprecated. Use "--new" instead.'),
@@ -1593,6 +1585,7 @@ class Archiver(
         subparsers = parser.add_subparsers(title="required arguments", metavar="<command>")
 
         self.build_parser_benchmarks(subparsers, common_parser, mid_common_parser)
+        self.build_parser_compact(subparsers, common_parser, mid_common_parser)
         self.build_parser_diff(subparsers, common_parser, mid_common_parser)
         self.build_parser_locks(subparsers, common_parser, mid_common_parser)
         self.build_parser_prune(subparsers, common_parser, mid_common_parser)
@@ -1712,47 +1705,6 @@ class Archiver(
         )
         define_archive_filters_group(subparser)
 
-        # borg compact
-        compact_epilog = process_epilog(
-            """
-        This command frees repository space by compacting segments.
-
-        Use this regularly to avoid running out of space - you do not need to use this
-        after each borg command though. It is especially useful after deleting archives,
-        because only compaction will really free repository space.
-
-        borg compact does not need a key, so it is possible to invoke it from the
-        client or also from the server.
-
-        Depending on the amount of segments that need compaction, it may take a while,
-        so consider using the ``--progress`` option.
-
-        A segment is compacted if the amount of saved space is above the percentage value
-        given by the ``--threshold`` option. If omitted, a threshold of 10% is used.
-        When using ``--verbose``, borg will output an estimate of the freed space.
-
-        See :ref:`separate_compaction` in Additional Notes for more details.
-        """
-        )
-        subparser = subparsers.add_parser(
-            "compact",
-            parents=[common_parser],
-            add_help=False,
-            description=self.do_compact.__doc__,
-            epilog=compact_epilog,
-            formatter_class=argparse.RawDescriptionHelpFormatter,
-            help="compact segment files / free space in repo",
-        )
-        subparser.set_defaults(func=self.do_compact)
-        subparser.add_argument(
-            "--threshold",
-            metavar="PERCENT",
-            dest="threshold",
-            type=int,
-            default=10,
-            help="set minimum threshold for saved space in PERCENT (Default: 10)",
-        )
-
         # borg create
         create_epilog = process_epilog(
             """
diff --git a/src/borg/archiver/compact.py b/src/borg/archiver/compact.py
new file mode 100644
index 000000000..cbf2038a1
--- /dev/null
+++ b/src/borg/archiver/compact.py
@@ -0,0 +1,66 @@
+import argparse
+
+from .common import with_repository
+from ..constants import *  # NOQA
+from ..helpers import EXIT_SUCCESS
+from ..helpers import Manifest
+
+from ..logger import create_logger
+
+logger = create_logger()
+
+
+class CompactMixIn:
+    @with_repository(manifest=False, exclusive=True)
+    def do_compact(self, args, repository):
+        """compact segment files in the repository"""
+        # see the comment in do_with_lock about why we do it like this:
+        data = repository.get(Manifest.MANIFEST_ID)
+        repository.put(Manifest.MANIFEST_ID, data)
+        threshold = args.threshold / 100
+        repository.commit(compact=True, threshold=threshold)
+        return EXIT_SUCCESS
+
+    def build_parser_compact(self, subparsers, common_parser, mid_common_parser):
+
+        from .common import process_epilog
+
+        compact_epilog = process_epilog(
+            """
+        This command frees repository space by compacting segments.
+
+        Use this regularly to avoid running out of space - you do not need to use this
+        after each borg command though. It is especially useful after deleting archives,
+        because only compaction will really free repository space.
+
+        borg compact does not need a key, so it is possible to invoke it from the
+        client or also from the server.
+
+        Depending on the amount of segments that need compaction, it may take a while,
+        so consider using the ``--progress`` option.
+
+        A segment is compacted if the amount of saved space is above the percentage value
+        given by the ``--threshold`` option. If omitted, a threshold of 10% is used.
+        When using ``--verbose``, borg will output an estimate of the freed space.
+
+        See :ref:`separate_compaction` in Additional Notes for more details.
+        """
+        )
+        subparser = subparsers.add_parser(
+            "compact",
+            parents=[common_parser],
+            add_help=False,
+            description=self.do_compact.__doc__,
+            epilog=compact_epilog,
+            formatter_class=argparse.RawDescriptionHelpFormatter,
+            help="compact segment files / free space in repo",
+        )
+        subparser.set_defaults(func=self.do_compact)
+        subparser.add_argument(
+            "--threshold",
+            metavar="PERCENT",
+            dest="threshold",
+            type=int,
+            default=10,
+            help="set minimum threshold for saved space in PERCENT (Default: 10)",
+        )

From 2ff2927aa3ab854893da37e616b66092d46312e1 Mon Sep 17 00:00:00 2001
From: Thomas Waldmann <tw@waldmann-edv.de>
Date: Fri, 8 Jul 2022 22:48:48 +0200
Subject: [PATCH 129/160] move check command to archiver.check

---
 src/borg/archiver/__init__.py | 171 +-------------------------------
 src/borg/archiver/check.py    | 182 ++++++++++++++++++++++++++++++++++
 2 files changed, 186 insertions(+), 167 deletions(-)
 create mode 100644 src/borg/archiver/check.py

diff --git a/src/borg/archiver/__init__.py b/src/borg/archiver/__init__.py
index 29759f4fd..6119851d5 100644
--- a/src/borg/archiver/__init__.py
+++ b/src/borg/archiver/__init__.py
@@ -28,7 +28,7 @@ try:
     from .common import with_repository, with_other_repository, with_archive, Highlander
     from .. import __version__
     from .. import helpers
-    from ..archive import Archive, ArchiveChecker, ArchiveRecreater, Statistics, is_special
+    from ..archive import Archive, ArchiveRecreater, Statistics, is_special
     from ..archive import BackupError, BackupOSError, backup_io, OsOpen, stat_update_check
     from ..archive import FilesystemObjectProcessors, MetadataCollector, ChunksProcessor
     from ..cache import Cache, SecurityManager
@@ -98,6 +98,7 @@ def get_func(args):
 
 
 from .benchmarks import BenchmarkMixIn
+from .check import CheckMixIn
 from .compact import CompactMixIn
 from .config import ConfigMixIn
 from .debug import DebugMixIn
@@ -111,6 +112,7 @@ from .transfer import TransferMixIn
 
 
 class Archiver(
+    CheckMixIn,
     ConfigMixIn,
     CompactMixIn,
     DebugMixIn,
@@ -197,57 +199,6 @@ class Archiver(
             )
         return self.exit_code
 
-    @with_repository(exclusive=True, manifest=False)
-    def do_check(self, args, repository):
-        """Check repository consistency"""
-        if args.repair:
-            msg = (
-                "This is a potentially dangerous function.\n"
-                "check --repair might lead to data loss (for kinds of corruption it is not\n"
-                "capable of dealing with). BE VERY CAREFUL!\n"
-                "\n"
-                "Type 'YES' if you understand this and want to continue: "
-            )
-            if not yes(
-                msg,
-                false_msg="Aborting.",
-                invalid_msg="Invalid answer, aborting.",
-                truish=("YES",),
-                retry=False,
-                env_var_override="BORG_CHECK_I_KNOW_WHAT_I_AM_DOING",
-            ):
-                return EXIT_ERROR
-        if args.repo_only and any((args.verify_data, args.first, args.last, args.glob_archives)):
-            self.print_error(
-                "--repository-only contradicts --first, --last, -a / --glob-archives " " and --verify-data arguments."
-            )
-            return EXIT_ERROR
-        if args.repair and args.max_duration:
-            self.print_error("--repair does not allow --max-duration argument.")
-            return EXIT_ERROR
-        if args.max_duration and not args.repo_only:
-            # when doing a partial repo check, we can only check crc32 checksums in segment files,
-            # we can't build a fresh repo index in memory to verify the on-disk index against it.
-            # thus, we should not do an archives check based on a unknown-quality on-disk repo index.
-            # also, there is no max_duration support in the archives check code anyway.
-            self.print_error("--repository-only is required for --max-duration support.")
-            return EXIT_ERROR
-        if not args.archives_only:
-            if not repository.check(repair=args.repair, save_space=args.save_space, max_duration=args.max_duration):
-                return EXIT_WARNING
-        if not args.repo_only and not ArchiveChecker().check(
-            repository,
-            repair=args.repair,
-            first=args.first,
-            last=args.last,
-            sort_by=args.sort_by or "ts",
-            glob=args.glob_archives,
-            verify_data=args.verify_data,
-            save_space=args.save_space,
-        ):
-            return EXIT_WARNING
-        return EXIT_SUCCESS
-
     @with_repository(fake="dry_run", exclusive=True, compatibility=(Manifest.Operation.WRITE,))
     def do_create(self, args, repository, manifest=None, key=None):
         """Create new archive"""
@@ -1585,126 +1536,12 @@ class Archiver(
         subparsers = parser.add_subparsers(title="required arguments", metavar="<command>")
 
         self.build_parser_benchmarks(subparsers, common_parser, mid_common_parser)
+        self.build_parser_check(subparsers, common_parser, mid_common_parser)
         self.build_parser_compact(subparsers, common_parser, mid_common_parser)
         self.build_parser_diff(subparsers, common_parser, mid_common_parser)
         self.build_parser_locks(subparsers, common_parser, mid_common_parser)
         self.build_parser_prune(subparsers, common_parser, mid_common_parser)
 
-        # borg check
-        check_epilog = process_epilog(
-            """
-        The check command verifies the consistency of a repository and the corresponding archives.
-
-        check --repair is a potentially dangerous function and might lead to data loss
-        (for kinds of corruption it is not capable of dealing with). BE VERY CAREFUL!
-
-        Pursuant to the previous warning it is also highly recommended to test the
-        reliability of the hardware running this software with stress testing software
-        such as memory testers. Unreliable hardware can also lead to data loss especially
-        when this command is run in repair mode.
-
-        First, the underlying repository data files are checked:
-
-        - For all segments, the segment magic header is checked.
-        - For all objects stored in the segments, all metadata (e.g. CRC and size) and
-          all data is read. The read data is checked by size and CRC. Bit rot and other
-          types of accidental damage can be detected this way.
-        - In repair mode, if an integrity error is detected in a segment, try to recover
-          as many objects from the segment as possible.
-        - In repair mode, make sure that the index is consistent with the data stored in
-          the segments.
-        - If checking a remote repo via ``ssh:``, the repo check is executed on the server
-          without causing significant network traffic.
-        - The repository check can be skipped using the ``--archives-only`` option.
-        - A repository check can be time consuming. Partial checks are possible with the
-          ``--max-duration`` option.
-
-        Second, the consistency and correctness of the archive metadata is verified:
-
-        - Is the repo manifest present? If not, it is rebuilt from archive metadata
-          chunks (this requires reading and decrypting of all metadata and data).
-        - Check if archive metadata chunk is present; if not, remove archive from manifest.
-        - For all files (items) in the archive, for all chunks referenced by these
-          files, check if chunk is present. In repair mode, if a chunk is not present,
-          replace it with a same-size replacement chunk of zeroes. If a previously lost
-          chunk reappears (e.g. via a later backup), in repair mode the all-zero replacement
-          chunk will be replaced by the correct chunk. This requires reading of archive and
-          file metadata, but not data.
-        - In repair mode, when all the archives were checked, orphaned chunks are deleted
-          from the repo. One cause of orphaned chunks are input file related errors (like
-          read errors) in the archive creation process.
-        - In verify-data mode, a complete cryptographic verification of the archive data
-          integrity is performed. This conflicts with ``--repository-only`` as this mode
-          only makes sense if the archive checks are enabled. The full details of this mode
-          are documented below.
-        - If checking a remote repo via ``ssh:``, the archive check is executed on the
-          client machine because it requires decryption, and this is always done client-side
-          as key access is needed.
-        - The archive checks can be time consuming; they can be skipped using the
-          ``--repository-only`` option.
-
-        The ``--max-duration`` option can be used to split a long-running repository check
-        into multiple partial checks. After the given number of seconds the check is
-        interrupted. The next partial check will continue where the previous one stopped,
-        until the complete repository has been checked. Example: Assuming a complete check took 7
-        hours, then running a daily check with --max-duration=3600 (1 hour) resulted in one
-        completed check per week.
-
-        Attention: A partial --repository-only check can only do way less checking than a full
-        --repository-only check: only the non-cryptographic checksum checks on segment file
-        entries are done, while a full --repository-only check would also do a repo index check.
-        A partial check cannot be combined with the ``--repair`` option. Partial checks
-        may therefore be useful only with very large repositories where a full check would take
-        too long.
-        Doing a full repository check aborts a partial check; the next partial check will restart
-        from the beginning.
-
-        The ``--verify-data`` option will perform a full integrity verification (as opposed to
-        checking the CRC32 of the segment) of data, which means reading the data from the
-        repository, decrypting and decompressing it. This is a cryptographic verification,
-        which will detect (accidental) corruption. For encrypted repositories it is
-        tamper-resistant as well, unless the attacker has access to the keys. It is also very
-        slow.
-        """
-        )
-        subparser = subparsers.add_parser(
-            "check",
-            parents=[common_parser],
-            add_help=False,
-            description=self.do_check.__doc__,
-            epilog=check_epilog,
-            formatter_class=argparse.RawDescriptionHelpFormatter,
-            help="verify repository",
-        )
-        subparser.set_defaults(func=self.do_check)
-        subparser.add_argument(
-            "--repository-only", dest="repo_only", action="store_true", help="only perform repository checks"
-        )
-        subparser.add_argument(
-            "--archives-only", dest="archives_only", action="store_true", help="only perform archives checks"
-        )
-        subparser.add_argument(
-            "--verify-data",
-            dest="verify_data",
-            action="store_true",
-            help="perform cryptographic archive data integrity verification " "(conflicts with ``--repository-only``)",
-        )
-        subparser.add_argument(
-            "--repair", dest="repair", action="store_true", help="attempt to repair any inconsistencies found"
-        )
-        subparser.add_argument(
-            "--save-space", dest="save_space", action="store_true", help="work slower, but using less space"
-        )
-        subparser.add_argument(
-            "--max-duration",
-            metavar="SECONDS",
-            dest="max_duration",
-            type=int,
-            default=0,
-            help="do only a partial repo check for max. SECONDS seconds (Default: unlimited)",
-        )
-        define_archive_filters_group(subparser)
-
         # borg create
         create_epilog = process_epilog(
             """
diff --git a/src/borg/archiver/check.py b/src/borg/archiver/check.py
new file mode 100644
index 000000000..75abc7231
--- /dev/null
+++ b/src/borg/archiver/check.py
@@ -0,0 +1,182 @@
+import argparse
+from .common import with_repository
+from ..archive import ArchiveChecker
+from ..constants import *  # NOQA
+from ..helpers import EXIT_SUCCESS, EXIT_WARNING, EXIT_ERROR
+from ..helpers import yes
+
+from ..logger import create_logger
+
+logger = create_logger()
+
+
+class CheckMixIn:
+    @with_repository(exclusive=True, manifest=False)
+    def do_check(self, args, repository):
+        """Check repository consistency"""
+        if args.repair:
+            msg = (
+                "This is a potentially dangerous function.\n"
+                "check --repair might lead to data loss (for kinds of corruption it is not\n"
+                "capable of dealing with). BE VERY CAREFUL!\n"
+                "\n"
+                "Type 'YES' if you understand this and want to continue: "
+            )
+            if not yes(
+                msg,
+                false_msg="Aborting.",
+                invalid_msg="Invalid answer, aborting.",
+                truish=("YES",),
+                retry=False,
+                env_var_override="BORG_CHECK_I_KNOW_WHAT_I_AM_DOING",
+            ):
+                return EXIT_ERROR
+        if args.repo_only and any((args.verify_data, args.first, args.last, args.glob_archives)):
+            self.print_error(
+                "--repository-only contradicts --first, --last, -a / --glob-archives " " and --verify-data arguments."
+            )
+            return EXIT_ERROR
+        if args.repair and args.max_duration:
+            self.print_error("--repair does not allow --max-duration argument.")
+            return EXIT_ERROR
+        if args.max_duration and not args.repo_only:
+            # when doing a partial repo check, we can only check crc32 checksums in segment files,
+            # we can't build a fresh repo index in memory to verify the on-disk index against it.
+            # thus, we should not do an archives check based on a unknown-quality on-disk repo index.
+            # also, there is no max_duration support in the archives check code anyway.
+            self.print_error("--repository-only is required for --max-duration support.")
+            return EXIT_ERROR
+        if not args.archives_only:
+            if not repository.check(repair=args.repair, save_space=args.save_space, max_duration=args.max_duration):
+                return EXIT_WARNING
+        if not args.repo_only and not ArchiveChecker().check(
+            repository,
+            repair=args.repair,
+            first=args.first,
+            last=args.last,
+            sort_by=args.sort_by or "ts",
+            glob=args.glob_archives,
+            verify_data=args.verify_data,
+            save_space=args.save_space,
+        ):
+            return EXIT_WARNING
+        return EXIT_SUCCESS
+
+    def build_parser_check(self, subparsers, common_parser, mid_common_parser):
+
+        from .common import process_epilog
+        from .common import define_archive_filters_group
+
+        check_epilog = process_epilog(
+            """
+        The check command verifies the consistency of a repository and the corresponding archives.
+
+        check --repair is a potentially dangerous function and might lead to data loss
+        (for kinds of corruption it is not capable of dealing with). BE VERY CAREFUL!
+
+        Pursuant to the previous warning it is also highly recommended to test the
+        reliability of the hardware running this software with stress testing software
+        such as memory testers. Unreliable hardware can also lead to data loss especially
+        when this command is run in repair mode.
+
+        First, the underlying repository data files are checked:
+
+        - For all segments, the segment magic header is checked.
+        - For all objects stored in the segments, all metadata (e.g. CRC and size) and
+          all data is read. The read data is checked by size and CRC. Bit rot and other
+          types of accidental damage can be detected this way.
+        - In repair mode, if an integrity error is detected in a segment, try to recover
+          as many objects from the segment as possible.
+        - In repair mode, make sure that the index is consistent with the data stored in
+          the segments.
+        - If checking a remote repo via ``ssh:``, the repo check is executed on the server
+          without causing significant network traffic.
+        - The repository check can be skipped using the ``--archives-only`` option.
+        - A repository check can be time consuming. Partial checks are possible with the
+          ``--max-duration`` option.
+
+        Second, the consistency and correctness of the archive metadata is verified:
+
+        - Is the repo manifest present? If not, it is rebuilt from archive metadata
+          chunks (this requires reading and decrypting of all metadata and data).
+        - Check if archive metadata chunk is present; if not, remove archive from manifest.
+        - For all files (items) in the archive, for all chunks referenced by these
+          files, check if chunk is present. In repair mode, if a chunk is not present,
+          replace it with a same-size replacement chunk of zeroes. If a previously lost
+          chunk reappears (e.g. via a later backup), in repair mode the all-zero replacement
+          chunk will be replaced by the correct chunk. This requires reading of archive and
+          file metadata, but not data.
+        - In repair mode, when all the archives were checked, orphaned chunks are deleted
+          from the repo. One cause of orphaned chunks are input file related errors (like
+          read errors) in the archive creation process.
+        - In verify-data mode, a complete cryptographic verification of the archive data
+          integrity is performed. This conflicts with ``--repository-only`` as this mode
+          only makes sense if the archive checks are enabled. The full details of this mode
+          are documented below.
+        - If checking a remote repo via ``ssh:``, the archive check is executed on the
+          client machine because it requires decryption, and this is always done client-side
+          as key access is needed.
+        - The archive checks can be time consuming; they can be skipped using the
+          ``--repository-only`` option.
+
+        The ``--max-duration`` option can be used to split a long-running repository check
+        into multiple partial checks. After the given number of seconds the check is
+        interrupted. The next partial check will continue where the previous one stopped,
+        until the complete repository has been checked. Example: Assuming a complete check took 7
+        hours, then running a daily check with --max-duration=3600 (1 hour) resulted in one
+        completed check per week.
+
+        Attention: A partial --repository-only check can only do way less checking than a full
+        --repository-only check: only the non-cryptographic checksum checks on segment file
+        entries are done, while a full --repository-only check would also do a repo index check.
+        A partial check cannot be combined with the ``--repair`` option. Partial checks
+        may therefore be useful only with very large repositories where a full check would take
+        too long.
+        Doing a full repository check aborts a partial check; the next partial check will restart
+        from the beginning.
+
+        The ``--verify-data`` option will perform a full integrity verification (as opposed to
+        checking the CRC32 of the segment) of data, which means reading the data from the
+        repository, decrypting and decompressing it. This is a cryptographic verification,
+        which will detect (accidental) corruption. For encrypted repositories it is
+        tamper-resistant as well, unless the attacker has access to the keys. It is also very
+        slow.
+        """
+        )
+        subparser = subparsers.add_parser(
+            "check",
+            parents=[common_parser],
+            add_help=False,
+            description=self.do_check.__doc__,
+            epilog=check_epilog,
+            formatter_class=argparse.RawDescriptionHelpFormatter,
+            help="verify repository",
+        )
+        subparser.set_defaults(func=self.do_check)
+        subparser.add_argument(
+            "--repository-only", dest="repo_only", action="store_true", help="only perform repository checks"
+        )
+        subparser.add_argument(
+            "--archives-only", dest="archives_only", action="store_true", help="only perform archives checks"
+        )
+        subparser.add_argument(
+            "--verify-data",
+            dest="verify_data",
+            action="store_true",
+            help="perform cryptographic archive data integrity verification " "(conflicts with ``--repository-only``)",
+        )
+        subparser.add_argument(
+            "--repair", dest="repair", action="store_true", help="attempt to repair any inconsistencies found"
+        )
+        subparser.add_argument(
+            "--save-space", dest="save_space", action="store_true", help="work slower, but using less space"
+        )
+        subparser.add_argument(
+            "--max-duration",
+            metavar="SECONDS",
+            dest="max_duration",
+            type=int,
+            default=0,
+            help="do only a partial repo check for max. SECONDS seconds (Default: unlimited)",
+        )
+        define_archive_filters_group(subparser)

From 68772484ceb60e59d98092a358eca3f8491f197f Mon Sep 17 00:00:00 2001
From: Thomas Waldmann <tw@waldmann-edv.de>
Date: Fri, 8 Jul 2022 23:54:00 +0200
Subject: [PATCH 130/160] move mount/umount/borgfs command to archiver.mount

---
 src/borg/archiver/__init__.py | 172 +-------------------------------
 src/borg/archiver/mount.py    | 181 ++++++++++++++++++++++++++++++++++
 2 files changed, 186 insertions(+), 167 deletions(-)
 create mode 100644 src/borg/archiver/mount.py

diff --git a/src/borg/archiver/__init__.py b/src/borg/archiver/__init__.py
index 6119851d5..0e510995c 100644
--- a/src/borg/archiver/__init__.py
+++ b/src/borg/archiver/__init__.py
@@ -53,7 +53,6 @@ try:
     from ..helpers import ErrorIgnoringTextIOWrapper
     from ..helpers import ProgressIndicatorPercent
     from ..helpers import basic_json_data, json_print
-    from ..helpers import umount
     from ..helpers import flags_root, flags_dir, flags_special_follow, flags_special
     from ..helpers import msgpack
     from ..helpers import sig_int
@@ -61,7 +60,7 @@ try:
     from ..patterns import PatternMatcher
     from ..platform import get_flags
     from ..platform import uid2user, gid2group
-    from ..remote import RepositoryServer, RemoteRepository, cache_if_remote
+    from ..remote import RepositoryServer, RemoteRepository
     from ..selftest import selftest
 except BaseException:
     # an unhandled exception in the try-block would cause the borg cli command to exit with rc 1 due to python's
@@ -106,6 +105,7 @@ from .diff import DiffMixIn
 from .help import HelpMixIn
 from .keys import KeysMixIn
 from .locks import LocksMixIn
+from .mount import MountMixIn
 from .prune import PruneMixIn
 from .tar import TarMixIn
 from .transfer import TransferMixIn
@@ -121,6 +121,7 @@ class Archiver(
     BenchmarkMixIn,
     KeysMixIn,
     LocksMixIn,
+    MountMixIn,
     PruneMixIn,
     HelpMixIn,
     TransferMixIn,
@@ -898,40 +899,6 @@ class Archiver(
 
         return self.exit_code
 
-    def do_mount(self, args):
-        """Mount archive or an entire repository as a FUSE filesystem"""
-        # Perform these checks before opening the repository and asking for a passphrase.
-
-        from ..fuse_impl import llfuse, BORG_FUSE_IMPL
-
-        if llfuse is None:
-            self.print_error("borg mount not available: no FUSE support, BORG_FUSE_IMPL=%s." % BORG_FUSE_IMPL)
-            return self.exit_code
-
-        if not os.path.isdir(args.mountpoint) or not os.access(args.mountpoint, os.R_OK | os.W_OK | os.X_OK):
-            self.print_error("%s: Mountpoint must be a writable directory" % args.mountpoint)
-            return self.exit_code
-
-        return self._do_mount(args)
-
-    @with_repository(compatibility=(Manifest.Operation.READ,))
-    def _do_mount(self, args, repository, manifest, key):
-        from ..fuse import FuseOperations
-
-        with cache_if_remote(repository, decrypted_cache=key) as cached_repo:
-            operations = FuseOperations(key, repository, manifest, args, cached_repo)
-            logger.info("Mounting filesystem")
-            try:
-                operations.mount(args.mountpoint, args.options, args.foreground)
-            except RuntimeError:
-                # Relevant error message already printed to stderr by FUSE
-                self.exit_code = EXIT_ERROR
-        return self.exit_code
-
-    def do_umount(self, args):
-        """un-mount the FUSE filesystem"""
-        return umount(args.mountpoint)
-
     @with_repository(compatibility=(Manifest.Operation.READ,))
     def do_list(self, args, repository, manifest, key):
         """List archive contents"""
@@ -1415,35 +1382,6 @@ class Archiver(
                 help="repository to use",
             )
 
-        def define_borg_mount(parser):
-            parser.set_defaults(func=self.do_mount)
-            parser.add_argument(
-                "--consider-checkpoints",
-                action="store_true",
-                dest="consider_checkpoints",
-                help="Show checkpoint archives in the repository contents list (default: hidden).",
-            )
-            parser.add_argument("mountpoint", metavar="MOUNTPOINT", type=str, help="where to mount filesystem")
-            parser.add_argument(
-                "-f",
-                "--foreground",
-                dest="foreground",
-                action="store_true",
-                help="stay in foreground, do not daemonize",
-            )
-            parser.add_argument("-o", dest="options", type=str, action=Highlander, help="Extra mount options")
-            parser.add_argument(
-                "--numeric-ids",
-                dest="numeric_ids",
-                action="store_true",
-                help="use numeric user and group identifiers from archive(s)",
-            )
-            define_archive_filters_group(parser)
-            parser.add_argument(
-                "paths", metavar="PATH", nargs="*", type=str, help="paths to extract; patterns are supported"
-            )
-            define_exclusion_group(parser, strip_components=True)
-
         parser = argparse.ArgumentParser(prog=self.prog, description="Borg - Deduplicated Backups", add_help=False)
         # paths and patterns must have an empty list as default everywhere
         parser.set_defaults(fallback2_func=functools.partial(self.do_maincommand_help, parser), paths=[], patterns=[])
@@ -1463,75 +1401,8 @@ class Archiver(
         mid_common_parser.set_defaults(paths=[], patterns=[])
         parser.common_options.add_common_group(mid_common_parser, "_midcommand")
 
-        # borg mount
-        mount_epilog = process_epilog(
-            """
-        This command mounts an archive as a FUSE filesystem. This can be useful
-        for browsing an archive or restoring individual files. When restoring,
-        take into account that the current FUSE implementation does not support
-        special fs flags and ACLs.
-
-        Unless the ``--foreground`` option is given the command will run in the
-        background until the filesystem is ``umounted``.
-
-        The command ``borgfs`` provides a wrapper for ``borg mount``. This can also be
-        used in fstab entries:
-        ``/path/to/repo /mnt/point fuse.borgfs defaults,noauto 0 0``
-
-        To allow a regular user to use fstab entries, add the ``user`` option:
-        ``/path/to/repo /mnt/point fuse.borgfs defaults,noauto,user 0 0``
-
-        For FUSE configuration and mount options, see the mount.fuse(8) manual page.
-
-        Borg's default behavior is to use the archived user and group names of each
-        file and map them to the system's respective user and group ids.
-        Alternatively, using ``numeric-ids`` will instead use the archived user and
-        group ids without any mapping.
-
-        The ``uid`` and ``gid`` mount options (implemented by Borg) can be used to
-        override the user and group ids of all files (i.e., ``borg mount -o
-        uid=1000,gid=1000``).
-
-        The man page references ``user_id`` and ``group_id`` mount options
-        (implemented by fuse) which specify the user and group id of the mount owner
-        (aka, the user who does the mounting). It is set automatically by libfuse (or
-        the filesystem if libfuse is not used). However, you should not specify these
-        manually. Unlike the ``uid`` and ``gid`` mount options which affect all files,
-        ``user_id`` and ``group_id`` affect the user and group id of the mounted
-        (base) directory.
-
-        Additional mount options supported by borg:
-
-        - versions: when used with a repository mount, this gives a merged, versioned
-          view of the files in the archives. EXPERIMENTAL, layout may change in future.
-        - allow_damaged_files: by default damaged files (where missing chunks were
-          replaced with runs of zeros by borg check ``--repair``) are not readable and
-          return EIO (I/O error). Set this option to read such files.
-        - ignore_permissions: for security reasons the "default_permissions" mount
-          option is internally enforced by borg. "ignore_permissions" can be given to
-          not enforce "default_permissions".
-
-        The BORG_MOUNT_DATA_CACHE_ENTRIES environment variable is meant for advanced users
-        to tweak the performance. It sets the number of cached data chunks; additional
-        memory usage can be up to ~8 MiB times this number. The default is the number
-        of CPU cores.
-
-        When the daemonized process receives a signal or crashes, it does not unmount.
-        Unmounting in these cases could cause an active rsync or similar process
-        to unintentionally delete data.
-
-        When running in the foreground ^C/SIGINT unmounts cleanly, but other
-        signals or crashes do not.
-        """
-        )
-
         if parser.prog == "borgfs":
-            parser.description = self.do_mount.__doc__
-            parser.epilog = mount_epilog
-            parser.formatter_class = argparse.RawDescriptionHelpFormatter
-            parser.help = "mount repository"
-            define_borg_mount(parser)
-            return parser
+            return self.build_parser_borgfs(parser)
 
         subparsers = parser.add_subparsers(title="required arguments", metavar="<command>")
 
@@ -1540,6 +1411,7 @@ class Archiver(
         self.build_parser_compact(subparsers, common_parser, mid_common_parser)
         self.build_parser_diff(subparsers, common_parser, mid_common_parser)
         self.build_parser_locks(subparsers, common_parser, mid_common_parser)
+        self.build_parser_mount_umount(subparsers, common_parser, mid_common_parser)
         self.build_parser_prune(subparsers, common_parser, mid_common_parser)
 
         # borg create
@@ -2492,17 +2364,6 @@ class Archiver(
         )
         define_archive_filters_group(subparser)
 
-        subparser = subparsers.add_parser(
-            "mount",
-            parents=[common_parser],
-            add_help=False,
-            description=self.do_mount.__doc__,
-            epilog=mount_epilog,
-            formatter_class=argparse.RawDescriptionHelpFormatter,
-            help="mount repository",
-        )
-        define_borg_mount(subparser)
-
         # borg recreate
         recreate_epilog = process_epilog(
             """
@@ -2743,29 +2604,6 @@ class Archiver(
             "repository as well. Default: no quota.",
         )
 
-        # borg umount
-        umount_epilog = process_epilog(
-            """
-        This command un-mounts a FUSE filesystem that was mounted with ``borg mount``.
-
-        This is a convenience wrapper that just calls the platform-specific shell
-        command - usually this is either umount or fusermount -u.
-        """
-        )
-        subparser = subparsers.add_parser(
-            "umount",
-            parents=[common_parser],
-            add_help=False,
-            description=self.do_umount.__doc__,
-            epilog=umount_epilog,
-            formatter_class=argparse.RawDescriptionHelpFormatter,
-            help="umount repository",
-        )
-        subparser.set_defaults(func=self.do_umount)
-        subparser.add_argument(
-            "mountpoint", metavar="MOUNTPOINT", type=str, help="mountpoint of the filesystem to umount"
-        )
-
         self.build_parser_tar(subparsers, common_parser, mid_common_parser)
 
         self.build_parser_transfer(subparsers, common_parser, mid_common_parser)
diff --git a/src/borg/archiver/mount.py b/src/borg/archiver/mount.py
new file mode 100644
index 000000000..8c23b69d0
--- /dev/null
+++ b/src/borg/archiver/mount.py
@@ -0,0 +1,181 @@
+import argparse
+import os
+
+from .common import with_repository, Highlander
+from ..constants import *  # NOQA
+from ..helpers import EXIT_ERROR
+from ..helpers import Manifest
+from ..helpers import umount
+from ..remote import cache_if_remote
+
+from ..logger import create_logger
+
+logger = create_logger()
+
+
+class MountMixIn:
+    def do_mount(self, args):
+        """Mount archive or an entire repository as a FUSE filesystem"""
+        # Perform these checks before opening the repository and asking for a passphrase.
+
+        from ..fuse_impl import llfuse, BORG_FUSE_IMPL
+
+        if llfuse is None:
+            self.print_error("borg mount not available: no FUSE support, BORG_FUSE_IMPL=%s." % BORG_FUSE_IMPL)
+            return self.exit_code
+
+        if not os.path.isdir(args.mountpoint) or not os.access(args.mountpoint, os.R_OK | os.W_OK | os.X_OK):
+            self.print_error("%s: Mountpoint must be a writable directory" % args.mountpoint)
+            return self.exit_code
+
+        return self._do_mount(args)
+
+    @with_repository(compatibility=(Manifest.Operation.READ,))
+    def _do_mount(self, args, repository, manifest, key):
+        from ..fuse import FuseOperations
+
+        with cache_if_remote(repository, decrypted_cache=key) as cached_repo:
+            operations = FuseOperations(key, repository, manifest, args, cached_repo)
+            logger.info("Mounting filesystem")
+            try:
+                operations.mount(args.mountpoint, args.options, args.foreground)
+            except RuntimeError:
+                # Relevant error message already printed to stderr by FUSE
+                self.exit_code = EXIT_ERROR
+        return self.exit_code
+
+    def do_umount(self, args):
+        """un-mount the FUSE filesystem"""
+        return umount(args.mountpoint)
+
+    def build_parser_mount_umount(self, subparsers, common_parser, mid_common_parser):
+        from .common import process_epilog
+
+        mount_epilog = process_epilog(
+            """
+        This command mounts an archive as a FUSE filesystem. This can be useful
+        for browsing an archive or restoring individual files. When restoring,
+        take into account that the current FUSE implementation does not support
+        special fs flags and ACLs.
+
+        Unless the ``--foreground`` option is given the command will run in the
+        background until the filesystem is ``umounted``.
+
+        The command ``borgfs`` provides a wrapper for ``borg mount``. This can also be
+        used in fstab entries:
+        ``/path/to/repo /mnt/point fuse.borgfs defaults,noauto 0 0``
+
+        To allow a regular user to use fstab entries, add the ``user`` option:
+        ``/path/to/repo /mnt/point fuse.borgfs defaults,noauto,user 0 0``
+
+        For FUSE configuration and mount options, see the mount.fuse(8) manual page.
+
+        Borg's default behavior is to use the archived user and group names of each
+        file and map them to the system's respective user and group ids.
+        Alternatively, using ``numeric-ids`` will instead use the archived user and
+        group ids without any mapping.
+
+        The ``uid`` and ``gid`` mount options (implemented by Borg) can be used to
+        override the user and group ids of all files (i.e., ``borg mount -o
+        uid=1000,gid=1000``).
+
+        The man page references ``user_id`` and ``group_id`` mount options
+        (implemented by fuse) which specify the user and group id of the mount owner
+        (aka, the user who does the mounting). It is set automatically by libfuse (or
+        the filesystem if libfuse is not used). However, you should not specify these
+        manually. Unlike the ``uid`` and ``gid`` mount options which affect all files,
+        ``user_id`` and ``group_id`` affect the user and group id of the mounted
+        (base) directory.
+
+        Additional mount options supported by borg:
+
+        - versions: when used with a repository mount, this gives a merged, versioned
+          view of the files in the archives. EXPERIMENTAL, layout may change in future.
+        - allow_damaged_files: by default damaged files (where missing chunks were
+          replaced with runs of zeros by borg check ``--repair``) are not readable and
+          return EIO (I/O error). Set this option to read such files.
+        - ignore_permissions: for security reasons the "default_permissions" mount
+          option is internally enforced by borg. "ignore_permissions" can be given to
+          not enforce "default_permissions".
+
+        The BORG_MOUNT_DATA_CACHE_ENTRIES environment variable is meant for advanced users
+        to tweak the performance. It sets the number of cached data chunks; additional
+        memory usage can be up to ~8 MiB times this number. The default is the number
+        of CPU cores.
+
+        When the daemonized process receives a signal or crashes, it does not unmount.
+        Unmounting in these cases could cause an active rsync or similar process
+        to unintentionally delete data.
+
+        When running in the foreground ^C/SIGINT unmounts cleanly, but other
+        signals or crashes do not.
+        """
+        )
+        subparser = subparsers.add_parser(
+            "mount",
+            parents=[common_parser],
+            add_help=False,
+            description=self.do_mount.__doc__,
+            epilog=mount_epilog,
+            formatter_class=argparse.RawDescriptionHelpFormatter,
+            help="mount repository",
+        )
+        self._define_borg_mount(subparser)
+
+        umount_epilog = process_epilog(
+            """
+        This command un-mounts a FUSE filesystem that was mounted with ``borg mount``.
+
+        This is a convenience wrapper that just calls the platform-specific shell
+        command - usually this is either umount or fusermount -u.
+        """
+        )
+        subparser = subparsers.add_parser(
+            "umount",
+            parents=[common_parser],
+            add_help=False,
+            description=self.do_umount.__doc__,
+            epilog=umount_epilog,
+            formatter_class=argparse.RawDescriptionHelpFormatter,
+            help="umount repository",
+        )
+        subparser.set_defaults(func=self.do_umount)
+        subparser.add_argument(
+            "mountpoint", metavar="MOUNTPOINT", type=str, help="mountpoint of the filesystem to umount"
+        )
+
+    def build_parser_borgfs(self, parser):
+        assert parser.prog == "borgfs"
+        parser.description = self.do_mount.__doc__
+        parser.epilog = "For more information, see borg mount --help."
+        parser.formatter_class = argparse.RawDescriptionHelpFormatter
+        parser.help = "mount repository"
+        self._define_borg_mount(parser)
+        return parser
+
+    def _define_borg_mount(self, parser):
+        from .common import define_exclusion_group, define_archive_filters_group
+
+        parser.set_defaults(func=self.do_mount)
+        parser.add_argument(
+            "--consider-checkpoints",
+            action="store_true",
+            dest="consider_checkpoints",
+            help="Show checkpoint archives in the repository contents list (default: hidden).",
+        )
+        parser.add_argument("mountpoint", metavar="MOUNTPOINT", type=str, help="where to mount filesystem")
+        parser.add_argument(
+            "-f", "--foreground", dest="foreground", action="store_true", help="stay in foreground, do not daemonize"
+        )
+        parser.add_argument("-o", dest="options", type=str, action=Highlander, help="Extra mount options")
+        parser.add_argument(
+            "--numeric-ids",
+            dest="numeric_ids",
+            action="store_true",
+            help="use numeric user and group identifiers from archive(s)",
+        )
+        define_archive_filters_group(parser)
+        parser.add_argument(
+            "paths", metavar="PATH", nargs="*", type=str, help="paths to extract; patterns are supported"
+        )
+        define_exclusion_group(parser, strip_components=True)

From ff411b5d98b64afb75b5ec3622fab3e13f75419b Mon Sep 17 00:00:00 2001
From: Thomas Waldmann <tw@waldmann-edv.de>
Date: Sat, 9 Jul 2022 00:14:17 +0200
Subject: [PATCH 131/160] move serve command to archiver.serve

---
 src/borg/archiver/__init__.py   | 82 ++-------------------------------
 src/borg/archiver/serve.py      | 82 +++++++++++++++++++++++++++++++++
 src/borg/helpers/parseformat.py |  7 +++
 3 files changed, 94 insertions(+), 77 deletions(-)
 create mode 100644 src/borg/archiver/serve.py

diff --git a/src/borg/archiver/__init__.py b/src/borg/archiver/__init__.py
index 0e510995c..9e3748334 100644
--- a/src/borg/archiver/__init__.py
+++ b/src/borg/archiver/__init__.py
@@ -40,7 +40,7 @@ try:
     from ..helpers import location_validator, archivename_validator, ChunkerParams, Location
     from ..helpers import NameSpec, CommentSpec, FilesCacheMode
     from ..helpers import BaseFormatter, ItemFormatter, ArchiveFormatter
-    from ..helpers import format_timedelta, format_file_size, parse_file_size, format_archive
+    from ..helpers import format_timedelta, format_file_size, format_archive, parse_storage_quota
     from ..helpers import remove_surrogates, bin_to_hex, eval_escapes
     from ..helpers import timestamp
     from ..helpers import get_cache_dir, os_stat
@@ -60,7 +60,7 @@ try:
     from ..patterns import PatternMatcher
     from ..platform import get_flags
     from ..platform import uid2user, gid2group
-    from ..remote import RepositoryServer, RemoteRepository
+    from ..remote import RemoteRepository
     from ..selftest import selftest
 except BaseException:
     # an unhandled exception in the try-block would cause the borg cli command to exit with rc 1 due to python's
@@ -77,13 +77,6 @@ STATS_HEADER = "                       Original size    Deduplicated size"
 PURE_PYTHON_MSGPACK_WARNING = "Using a pure-python msgpack! This will result in lower performance."
 
 
-def parse_storage_quota(storage_quota):
-    parsed = parse_file_size(storage_quota)
-    if parsed < parse_file_size("10M"):
-        raise argparse.ArgumentTypeError("quota is too small (%s). At least 10M are required." % storage_quota)
-    return parsed
-
-
 def get_func(args):
     # This works around https://bugs.python.org/issue9351
     # func is used at the leaf parsers of the argparse parser tree,
@@ -107,6 +100,7 @@ from .keys import KeysMixIn
 from .locks import LocksMixIn
 from .mount import MountMixIn
 from .prune import PruneMixIn
+from .serve import ServeMixIn
 from .tar import TarMixIn
 from .transfer import TransferMixIn
 
@@ -124,6 +118,7 @@ class Archiver(
     MountMixIn,
     PruneMixIn,
     HelpMixIn,
+    ServeMixIn,
     TransferMixIn,
 ):
     def __init__(self, lock_wait=None, prog=None):
@@ -159,16 +154,6 @@ class Archiver(
         matcher.add_includepaths(include_paths)
         return matcher
 
-    def do_serve(self, args):
-        """Start in server mode. This command is usually not used manually."""
-        RepositoryServer(
-            restrict_to_paths=args.restrict_to_paths,
-            restrict_to_repositories=args.restrict_to_repositories,
-            append_only=args.append_only,
-            storage_quota=args.storage_quota,
-        ).serve()
-        return EXIT_SUCCESS
-
     @with_repository(create=True, exclusive=True, manifest=False)
     @with_other_repository(key=True, compatibility=(Manifest.Operation.READ,))
     def do_rcreate(self, args, repository, *, other_repository=None, other_key=None):
@@ -2546,64 +2531,7 @@ class Archiver(
             "newname", metavar="NEWNAME", type=archivename_validator(), help="specify the new archive name"
         )
 
-        # borg serve
-        serve_epilog = process_epilog(
-            """
-        This command starts a repository server process. This command is usually not used manually.
-        """
-        )
-        subparser = subparsers.add_parser(
-            "serve",
-            parents=[common_parser],
-            add_help=False,
-            description=self.do_serve.__doc__,
-            epilog=serve_epilog,
-            formatter_class=argparse.RawDescriptionHelpFormatter,
-            help="start repository server process",
-        )
-        subparser.set_defaults(func=self.do_serve)
-        subparser.add_argument(
-            "--restrict-to-path",
-            metavar="PATH",
-            dest="restrict_to_paths",
-            action="append",
-            help="restrict repository access to PATH. "
-            "Can be specified multiple times to allow the client access to several directories. "
-            "Access to all sub-directories is granted implicitly; PATH doesn't need to directly point to a repository.",
-        )
-        subparser.add_argument(
-            "--restrict-to-repository",
-            metavar="PATH",
-            dest="restrict_to_repositories",
-            action="append",
-            help="restrict repository access. Only the repository located at PATH "
-            "(no sub-directories are considered) is accessible. "
-            "Can be specified multiple times to allow the client access to several repositories. "
-            "Unlike ``--restrict-to-path`` sub-directories are not accessible; "
-            "PATH needs to directly point at a repository location. "
-            "PATH may be an empty directory or the last element of PATH may not exist, in which case "
-            "the client may initialize a repository there.",
-        )
-        subparser.add_argument(
-            "--append-only",
-            dest="append_only",
-            action="store_true",
-            help="only allow appending to repository segment files. Note that this only "
-            "affects the low level structure of the repository, and running `delete` "
-            "or `prune` will still be allowed. See :ref:`append_only_mode` in Additional "
-            "Notes for more details.",
-        )
-        subparser.add_argument(
-            "--storage-quota",
-            metavar="QUOTA",
-            dest="storage_quota",
-            type=parse_storage_quota,
-            default=None,
-            help="Override storage quota of the repository (e.g. 5G, 1.5T). "
-            "When a new repository is initialized, sets the storage quota on the new "
-            "repository as well. Default: no quota.",
-        )
-
+        self.build_parser_serve(subparsers, common_parser, mid_common_parser)
         self.build_parser_tar(subparsers, common_parser, mid_common_parser)
 
         self.build_parser_transfer(subparsers, common_parser, mid_common_parser)
diff --git a/src/borg/archiver/serve.py b/src/borg/archiver/serve.py
new file mode 100644
index 000000000..4aa6c4a57
--- /dev/null
+++ b/src/borg/archiver/serve.py
@@ -0,0 +1,82 @@
+import argparse
+
+from ..constants import *  # NOQA
+from ..helpers import EXIT_SUCCESS
+from ..helpers import parse_storage_quota
+from ..remote import RepositoryServer
+
+from ..logger import create_logger
+
+logger = create_logger()
+
+
+class ServeMixIn:
+    def do_serve(self, args):
+        """Start in server mode. This command is usually not used manually."""
+        RepositoryServer(
+            restrict_to_paths=args.restrict_to_paths,
+            restrict_to_repositories=args.restrict_to_repositories,
+            append_only=args.append_only,
+            storage_quota=args.storage_quota,
+        ).serve()
+        return EXIT_SUCCESS
+
+    def build_parser_serve(self, subparsers, common_parser, mid_common_parser):
+        from .common import process_epilog
+
+        serve_epilog = process_epilog(
+            """
+        This command starts a repository server process. This command is usually not used manually.
+        """
+        )
+        subparser = subparsers.add_parser(
+            "serve",
+            parents=[common_parser],
+            add_help=False,
+            description=self.do_serve.__doc__,
+            epilog=serve_epilog,
+            formatter_class=argparse.RawDescriptionHelpFormatter,
+            help="start repository server process",
+        )
+        subparser.set_defaults(func=self.do_serve)
+        subparser.add_argument(
+            "--restrict-to-path",
+            metavar="PATH",
+            dest="restrict_to_paths",
+            action="append",
+            help="restrict repository access to PATH. "
+            "Can be specified multiple times to allow the client access to several directories. "
+            "Access to all sub-directories is granted implicitly; PATH doesn't need to directly point to a repository.",
+        )
+        subparser.add_argument(
+            "--restrict-to-repository",
+            metavar="PATH",
+            dest="restrict_to_repositories",
+            action="append",
+            help="restrict repository access. Only the repository located at PATH "
+            "(no sub-directories are considered) is accessible. "
+            "Can be specified multiple times to allow the client access to several repositories. "
+            "Unlike ``--restrict-to-path`` sub-directories are not accessible; "
+            "PATH needs to directly point at a repository location. "
+            "PATH may be an empty directory or the last element of PATH may not exist, in which case "
+            "the client may initialize a repository there.",
+        )
+        subparser.add_argument(
+            "--append-only",
+            dest="append_only",
+            action="store_true",
+            help="only allow appending to repository segment files. Note that this only "
+            "affects the low level structure of the repository, and running `delete` "
+            "or `prune` will still be allowed. See :ref:`append_only_mode` in Additional "
+            "Notes for more details.",
+        )
+        subparser.add_argument(
+            "--storage-quota",
+            metavar="QUOTA",
+            dest="storage_quota",
+            type=parse_storage_quota,
+            default=None,
+            help="Override storage quota of the repository (e.g. 5G, 1.5T). "
+            "When a new repository is initialized, sets the storage quota on the new "
+            "repository as well. Default: no quota.",
+        )
diff --git a/src/borg/helpers/parseformat.py b/src/borg/helpers/parseformat.py
index b058ada99..69ea17237 100644
--- a/src/borg/helpers/parseformat.py
+++ b/src/borg/helpers/parseformat.py
@@ -257,6 +257,13 @@ def parse_file_size(s):
     return int(float(s) * factor)
 
 
+def parse_storage_quota(storage_quota):
+    parsed = parse_file_size(storage_quota)
+    if parsed < parse_file_size("10M"):
+        raise argparse.ArgumentTypeError("quota is too small (%s). At least 10M are required." % storage_quota)
+    return parsed
+
+
 def sizeof_fmt(num, suffix="B", units=None, power=None, sep="", precision=2, sign=False):
     sign = "+" if sign and num > 0 else ""
     fmt = "{0:{1}.{2}f}{3}{4}{5}"

From 94aec46a01b50e436506bef3489f24df87b19ee8 Mon Sep 17 00:00:00 2001
From: Thomas Waldmann <tw@waldmann-edv.de>
Date: Sat, 9 Jul 2022 00:40:51 +0200
Subject: [PATCH 132/160] move rcreate command to archiver.rcreate

---
 src/borg/archiver/__init__.py  | 198 +------------------------------
 src/borg/archiver/rcreate.py   | 208 +++++++++++++++++++++++++++++++++
 src/borg/testsuite/archiver.py |   3 +-
 3 files changed, 215 insertions(+), 194 deletions(-)
 create mode 100644 src/borg/archiver/rcreate.py

diff --git a/src/borg/archiver/__init__.py b/src/borg/archiver/__init__.py
index 9e3748334..8f3ca5267 100644
--- a/src/borg/archiver/__init__.py
+++ b/src/borg/archiver/__init__.py
@@ -25,7 +25,7 @@ try:
 
     logger = create_logger()
 
-    from .common import with_repository, with_other_repository, with_archive, Highlander
+    from .common import with_repository, with_archive, Highlander
     from .. import __version__
     from .. import helpers
     from ..archive import Archive, ArchiveRecreater, Statistics, is_special
@@ -34,13 +34,12 @@ try:
     from ..cache import Cache, SecurityManager
     from ..constants import *  # NOQA
     from ..compress import CompressionSpec
-    from ..crypto.key import key_creator, key_argument_names, tam_required_file
     from ..helpers import EXIT_SUCCESS, EXIT_WARNING, EXIT_ERROR, EXIT_SIGNAL_BASE
     from ..helpers import Error, NoManifestError, set_ec
     from ..helpers import location_validator, archivename_validator, ChunkerParams, Location
     from ..helpers import NameSpec, CommentSpec, FilesCacheMode
     from ..helpers import BaseFormatter, ItemFormatter, ArchiveFormatter
-    from ..helpers import format_timedelta, format_file_size, format_archive, parse_storage_quota
+    from ..helpers import format_timedelta, format_file_size, format_archive
     from ..helpers import remove_surrogates, bin_to_hex, eval_escapes
     from ..helpers import timestamp
     from ..helpers import get_cache_dir, os_stat
@@ -100,6 +99,7 @@ from .keys import KeysMixIn
 from .locks import LocksMixIn
 from .mount import MountMixIn
 from .prune import PruneMixIn
+from .rcreate import RCreateMixIn
 from .serve import ServeMixIn
 from .tar import TarMixIn
 from .transfer import TransferMixIn
@@ -118,6 +118,7 @@ class Archiver(
     MountMixIn,
     PruneMixIn,
     HelpMixIn,
+    RCreateMixIn,
     ServeMixIn,
     TransferMixIn,
 ):
@@ -154,37 +155,6 @@ class Archiver(
         matcher.add_includepaths(include_paths)
         return matcher
 
-    @with_repository(create=True, exclusive=True, manifest=False)
-    @with_other_repository(key=True, compatibility=(Manifest.Operation.READ,))
-    def do_rcreate(self, args, repository, *, other_repository=None, other_key=None):
-        """Create a new, empty repository"""
-        path = args.location.canonical_path()
-        logger.info('Initializing repository at "%s"' % path)
-        try:
-            key = key_creator(repository, args, other_key=other_key)
-        except (EOFError, KeyboardInterrupt):
-            repository.destroy()
-            return EXIT_WARNING
-        manifest = Manifest(key, repository)
-        manifest.key = key
-        manifest.write()
-        repository.commit(compact=False)
-        with Cache(repository, key, manifest, warn_if_unencrypted=False):
-            pass
-        if key.tam_required:
-            tam_file = tam_required_file(repository)
-            open(tam_file, "w").close()
-
-        if key.NAME != "plaintext":
-            logger.warning(
-                "\n"
-                "IMPORTANT: you will need both KEY AND PASSPHRASE to access this repo!\n"
-                "If you used a repokey mode, the key is stored in the repo, but you should back it up separately.\n"
-                'Use "borg key export" to export the key, optionally in printable format.\n'
-                "Write down the passphrase. Store both at safe place(s).\n"
-            )
-        return self.exit_code
-
     @with_repository(fake="dry_run", exclusive=True, compatibility=(Manifest.Operation.WRITE,))
     def do_create(self, args, repository, manifest=None, key=None):
         """Create new archive"""
@@ -2029,166 +1999,8 @@ class Archiver(
         subparser.add_argument("--json", action="store_true", help="format output as JSON")
         define_archive_filters_group(subparser)
 
-        # borg rcreate
-        rcreate_epilog = process_epilog(
-            """
-        This command creates a new, empty repository. A repository is a filesystem
-        directory containing the deduplicated data from zero or more archives.
-
-        Encryption mode TLDR
-        ++++++++++++++++++++
-
-        The encryption mode can only be configured when creating a new repository - you can
-        neither configure it on a per-archive basis nor change the mode of an existing repository.
-        This example will likely NOT give optimum performance on your machine (performance
-        tips will come below):
-
-        ::
-
-            borg rcreate --encryption repokey-aes-ocb
-
-        Borg will:
-
-        1. Ask you to come up with a passphrase.
-        2. Create a borg key (which contains some random secrets. See :ref:`key_files`).
-        3. Derive a "key encryption key" from your passphrase
-        4. Encrypt and sign the key with the key encryption key
-        5. Store the encrypted borg key inside the repository directory (in the repo config).
-           This is why it is essential to use a secure passphrase.
-        6. Encrypt and sign your backups to prevent anyone from reading or forging them unless they
-           have the key and know the passphrase. Make sure to keep a backup of
-           your key **outside** the repository - do not lock yourself out by
-           "leaving your keys inside your car" (see :ref:`borg_key_export`).
-           For remote backups the encryption is done locally - the remote machine
-           never sees your passphrase, your unencrypted key or your unencrypted files.
-           Chunking and id generation are also based on your key to improve
-           your privacy.
-        7. Use the key when extracting files to decrypt them and to verify that the contents of
-           the backups have not been accidentally or maliciously altered.
-
-        Picking a passphrase
-        ++++++++++++++++++++
-
-        Make sure you use a good passphrase. Not too short, not too simple. The real
-        encryption / decryption key is encrypted with / locked by your passphrase.
-        If an attacker gets your key, he can't unlock and use it without knowing the
-        passphrase.
-
-        Be careful with special or non-ascii characters in your passphrase:
-
-        - Borg processes the passphrase as unicode (and encodes it as utf-8),
-          so it does not have problems dealing with even the strangest characters.
-        - BUT: that does not necessarily apply to your OS / VM / keyboard configuration.
-
-        So better use a long passphrase made from simple ascii chars than one that
-        includes non-ascii stuff or characters that are hard/impossible to enter on
-        a different keyboard layout.
-
-        You can change your passphrase for existing repos at any time, it won't affect
-        the encryption/decryption key or other secrets.
-
-        Choosing an encryption mode
-        +++++++++++++++++++++++++++
-
-        Depending on your hardware, hashing and crypto performance may vary widely.
-        The easiest way to find out about what's fastest is to run ``borg benchmark cpu``.
-
-        `repokey` modes: if you want ease-of-use and "passphrase" security is good enough -
-        the key will be stored in the repository (in ``repo_dir/config``).
-
-        `keyfile` modes: if you rather want "passphrase and having-the-key" security -
-        the key will be stored in your home directory (in ``~/.config/borg/keys``).
-
-        The following table is roughly sorted in order of preference, the better ones are
-        in the upper part of the table, in the lower part is the old and/or unsafe(r) stuff:
-
-        .. nanorst: inline-fill
-
-        +-----------------------------------+--------------+----------------+--------------------+---------+
-        | Mode (K = keyfile or repokey)     | ID-Hash      | Encryption     | Authentication     | V >=    |
-        +-----------------------------------+--------------+----------------+--------------------+---------+
-        | K-blake2-chacha20-poly1305        | BLAKE2b      | CHACHA20       | POLY1305           | 2.0     |
-        +-----------------------------------+--------------+----------------+--------------------+---------+
-        | K-chacha20-poly1305               | HMAC-SHA-256 | CHACHA20       | POLY1305           | 2.0     |
-        +-----------------------------------+--------------+----------------+--------------------+---------+
-        | K-blake2-aes-ocb                  | BLAKE2b      | AES256-OCB     | AES256-OCB         | 2.0     |
-        +-----------------------------------+--------------+----------------+--------------------+---------+
-        | K-aes-ocb                         | HMAC-SHA-256 | AES256-OCB     | AES256-OCB         | 2.0     |
-        +-----------------------------------+--------------+----------------+--------------------+---------+
-        | K-blake2                          | BLAKE2b      | AES256-CTR     | BLAKE2b            | 1.1     |
-        +-----------------------------------+--------------+----------------+--------------------+---------+
-        | K                                 | HMAC-SHA-256 | AES256-CTR     | HMAC-SHA256        | any     |
-        +-----------------------------------+--------------+----------------+--------------------+---------+
-        | authenticated-blake2              | BLAKE2b      | none           | BLAKE2b            | 1.1     |
-        +-----------------------------------+--------------+----------------+--------------------+---------+
-        | authenticated                     | HMAC-SHA-256 | none           | HMAC-SHA256        | 1.1     |
-        +-----------------------------------+--------------+----------------+--------------------+---------+
-        | none                              | SHA-256      | none           | none               | any     |
-        +-----------------------------------+--------------+----------------+--------------------+---------+
-
-        .. nanorst: inline-replace
-
-        `none` mode uses no encryption and no authentication. You're advised to NOT use this mode
-        as it would expose you to all sorts of issues (DoS, confidentiality, tampering, ...) in
-        case of malicious activity in the repository.
-
-        If you do **not** want to encrypt the contents of your backups, but still want to detect
-        malicious tampering use an `authenticated` mode. It's like `repokey` minus encryption.
-
-        """
-        )
-        subparser = subparsers.add_parser(
-            "rcreate",
-            parents=[common_parser],
-            add_help=False,
-            description=self.do_rcreate.__doc__,
-            epilog=rcreate_epilog,
-            formatter_class=argparse.RawDescriptionHelpFormatter,
-            help="create a new, empty repository",
-        )
-        subparser.set_defaults(func=self.do_rcreate)
-        subparser.add_argument(
-            "--other-repo",
-            metavar="SRC_REPOSITORY",
-            dest="other_location",
-            type=location_validator(other=True),
-            default=Location(other=True),
-            help="reuse the key material from the other repository",
-        )
-        subparser.add_argument(
-            "-e",
-            "--encryption",
-            metavar="MODE",
-            dest="encryption",
-            required=True,
-            choices=key_argument_names(),
-            help="select encryption key mode **(required)**",
-        )
-        subparser.add_argument(
-            "--append-only",
-            dest="append_only",
-            action="store_true",
-            help="create an append-only mode repository. Note that this only affects "
-            "the low level structure of the repository, and running `delete` "
-            "or `prune` will still be allowed. See :ref:`append_only_mode` in "
-            "Additional Notes for more details.",
-        )
-        subparser.add_argument(
-            "--storage-quota",
-            metavar="QUOTA",
-            dest="storage_quota",
-            default=None,
-            type=parse_storage_quota,
-            help="Set storage quota of the new repository (e.g. 5G, 1.5T). Default: no quota.",
-        )
-        subparser.add_argument(
-            "--make-parent-dirs",
-            dest="make_parent_dirs",
-            action="store_true",
-            help="create the parent directories of the repository directory, if they are missing.",
-        )
-
         self.build_parser_keys(subparsers, common_parser, mid_common_parser)
+        self.build_parser_rcreate(subparsers, common_parser, mid_common_parser)
 
         # borg list
         list_epilog = (
diff --git a/src/borg/archiver/rcreate.py b/src/borg/archiver/rcreate.py
new file mode 100644
index 000000000..c30fbc7b1
--- /dev/null
+++ b/src/borg/archiver/rcreate.py
@@ -0,0 +1,208 @@
+import argparse
+
+from .common import with_repository, with_other_repository
+from ..cache import Cache
+from ..constants import *  # NOQA
+from ..crypto.key import key_creator, key_argument_names, tam_required_file
+from ..helpers import EXIT_WARNING
+from ..helpers import location_validator, Location
+from ..helpers import parse_storage_quota
+from ..helpers import Manifest
+
+from ..logger import create_logger
+
+logger = create_logger()
+
+
+class RCreateMixIn:
+    @with_repository(create=True, exclusive=True, manifest=False)
+    @with_other_repository(key=True, compatibility=(Manifest.Operation.READ,))
+    def do_rcreate(self, args, repository, *, other_repository=None, other_key=None):
+        """Create a new, empty repository"""
+        path = args.location.canonical_path()
+        logger.info('Initializing repository at "%s"' % path)
+        try:
+            key = key_creator(repository, args, other_key=other_key)
+        except (EOFError, KeyboardInterrupt):
+            repository.destroy()
+            return EXIT_WARNING
+        manifest = Manifest(key, repository)
+        manifest.key = key
+        manifest.write()
+        repository.commit(compact=False)
+        with Cache(repository, key, manifest, warn_if_unencrypted=False):
+            pass
+        if key.tam_required:
+            tam_file = tam_required_file(repository)
+            open(tam_file, "w").close()
+
+        if key.NAME != "plaintext":
+            logger.warning(
+                "\n"
+                "IMPORTANT: you will need both KEY AND PASSPHRASE to access this repo!\n"
+                "If you used a repokey mode, the key is stored in the repo, but you should back it up separately.\n"
+                'Use "borg key export" to export the key, optionally in printable format.\n'
+                "Write down the passphrase. Store both at safe place(s).\n"
+            )
+        return self.exit_code
+
+    def build_parser_rcreate(self, subparsers, common_parser, mid_common_parser):
+        from .common import process_epilog
+
+        rcreate_epilog = process_epilog(
+            """
+        This command creates a new, empty repository. A repository is a filesystem
+        directory containing the deduplicated data from zero or more archives.
+
+        Encryption mode TLDR
+        ++++++++++++++++++++
+
+        The encryption mode can only be configured when creating a new repository - you can
+        neither configure it on a per-archive basis nor change the mode of an existing repository.
+        This example will likely NOT give optimum performance on your machine (performance
+        tips will come below):
+
+        ::
+
+            borg rcreate --encryption repokey-aes-ocb
+
+        Borg will:
+
+        1. Ask you to come up with a passphrase.
+        2. Create a borg key (which contains some random secrets. See :ref:`key_files`).
+        3. Derive a "key encryption key" from your passphrase
+        4. Encrypt and sign the key with the key encryption key
+        5. Store the encrypted borg key inside the repository directory (in the repo config).
+           This is why it is essential to use a secure passphrase.
+        6. Encrypt and sign your backups to prevent anyone from reading or forging them unless they
+           have the key and know the passphrase. Make sure to keep a backup of
+           your key **outside** the repository - do not lock yourself out by
+           "leaving your keys inside your car" (see :ref:`borg_key_export`).
+           For remote backups the encryption is done locally - the remote machine
+           never sees your passphrase, your unencrypted key or your unencrypted files.
+           Chunking and id generation are also based on your key to improve
+           your privacy.
+        7. Use the key when extracting files to decrypt them and to verify that the contents of
+           the backups have not been accidentally or maliciously altered.
+
+        Picking a passphrase
+        ++++++++++++++++++++
+
+        Make sure you use a good passphrase. Not too short, not too simple. The real
+        encryption / decryption key is encrypted with / locked by your passphrase.
+        If an attacker gets your key, he can't unlock and use it without knowing the
+        passphrase.
+
+        Be careful with special or non-ascii characters in your passphrase:
+
+        - Borg processes the passphrase as unicode (and encodes it as utf-8),
+          so it does not have problems dealing with even the strangest characters.
+        - BUT: that does not necessarily apply to your OS / VM / keyboard configuration.
+
+        So better use a long passphrase made from simple ascii chars than one that
+        includes non-ascii stuff or characters that are hard/impossible to enter on
+        a different keyboard layout.
+
+        You can change your passphrase for existing repos at any time, it won't affect
+        the encryption/decryption key or other secrets.
+
+        Choosing an encryption mode
+        +++++++++++++++++++++++++++
+
+        Depending on your hardware, hashing and crypto performance may vary widely.
+        The easiest way to find out about what's fastest is to run ``borg benchmark cpu``.
+
+        `repokey` modes: if you want ease-of-use and "passphrase" security is good enough -
+        the key will be stored in the repository (in ``repo_dir/config``).
+
+        `keyfile` modes: if you rather want "passphrase and having-the-key" security -
+        the key will be stored in your home directory (in ``~/.config/borg/keys``).
+
+        The following table is roughly sorted in order of preference, the better ones are
+        in the upper part of the table, in the lower part is the old and/or unsafe(r) stuff:
+
+        .. nanorst: inline-fill
+
+        +-----------------------------------+--------------+----------------+--------------------+---------+
+        | Mode (K = keyfile or repokey)     | ID-Hash      | Encryption     | Authentication     | V >=    |
+        +-----------------------------------+--------------+----------------+--------------------+---------+
+        | K-blake2-chacha20-poly1305        | BLAKE2b      | CHACHA20       | POLY1305           | 2.0     |
+        +-----------------------------------+--------------+----------------+--------------------+---------+
+        | K-chacha20-poly1305               | HMAC-SHA-256 | CHACHA20       | POLY1305           | 2.0     |
+        +-----------------------------------+--------------+----------------+--------------------+---------+
+        | K-blake2-aes-ocb                  | BLAKE2b      | AES256-OCB     | AES256-OCB         | 2.0     |
+        +-----------------------------------+--------------+----------------+--------------------+---------+
+        | K-aes-ocb                         | HMAC-SHA-256 | AES256-OCB     | AES256-OCB         | 2.0     |
+        +-----------------------------------+--------------+----------------+--------------------+---------+
+        | K-blake2                          | BLAKE2b      | AES256-CTR     | BLAKE2b            | 1.1     |
+        +-----------------------------------+--------------+----------------+--------------------+---------+
+        | K                                 | HMAC-SHA-256 | AES256-CTR     | HMAC-SHA256        | any     |
+        +-----------------------------------+--------------+----------------+--------------------+---------+
+        | authenticated-blake2              | BLAKE2b      | none           | BLAKE2b            | 1.1     |
+        +-----------------------------------+--------------+----------------+--------------------+---------+
+        | authenticated                     | HMAC-SHA-256 | none           | HMAC-SHA256        | 1.1     |
+        +-----------------------------------+--------------+----------------+--------------------+---------+
+        | none                              | SHA-256      | none           | none               | any     |
+        +-----------------------------------+--------------+----------------+--------------------+---------+
+
+        .. nanorst: inline-replace
+
+        `none` mode uses no encryption and no authentication. You're advised to NOT use this mode
+        as it would expose you to all sorts of issues (DoS, confidentiality, tampering, ...) in
+        case of malicious activity in the repository.
+
+        If you do **not** want to encrypt the contents of your backups, but still want to detect
+        malicious tampering use an `authenticated` mode. It's like `repokey` minus encryption.
+
+        """
+        )
+        subparser = subparsers.add_parser(
+            "rcreate",
+            parents=[common_parser],
+            add_help=False,
+            description=self.do_rcreate.__doc__,
+            epilog=rcreate_epilog,
+            formatter_class=argparse.RawDescriptionHelpFormatter,
+            help="create a new, empty repository",
+        )
+        subparser.set_defaults(func=self.do_rcreate)
+        subparser.add_argument(
+            "--other-repo",
+            metavar="SRC_REPOSITORY",
+            dest="other_location",
+            type=location_validator(other=True),
+            default=Location(other=True),
+            help="reuse the key material from the other repository",
+        )
+        subparser.add_argument(
+            "-e",
+            "--encryption",
+            metavar="MODE",
+            dest="encryption",
+            required=True,
+            choices=key_argument_names(),
+            help="select encryption key mode **(required)**",
+        )
+        subparser.add_argument(
+            "--append-only",
+            dest="append_only",
+            action="store_true",
+            help="create an append-only mode repository. Note that this only affects "
+            "the low level structure of the repository, and running `delete` "
+            "or `prune` will still be allowed. See :ref:`append_only_mode` in "
+            "Additional Notes for more details.",
+        )
+        subparser.add_argument(
+            "--storage-quota",
+            metavar="QUOTA",
+            dest="storage_quota",
+            default=None,
+            type=parse_storage_quota,
+            help="Set storage quota of the new repository (e.g. 5G, 1.5T). Default: no quota.",
+        )
+        subparser.add_argument(
+            "--make-parent-dirs",
+            dest="make_parent_dirs",
+            action="store_true",
+            help="create the parent directories of the repository directory, if they are missing.",
+        )
diff --git a/src/borg/testsuite/archiver.py b/src/borg/testsuite/archiver.py
index 5b371bab1..0561dabe7 100644
--- a/src/borg/testsuite/archiver.py
+++ b/src/borg/testsuite/archiver.py
@@ -31,7 +31,7 @@ import borg
 import borg.helpers.errors
 from .. import xattr, helpers, platform
 from ..archive import Archive, ChunkBuffer
-from ..archiver import Archiver, parse_storage_quota, PURE_PYTHON_MSGPACK_WARNING
+from ..archiver import Archiver, PURE_PYTHON_MSGPACK_WARNING
 from ..cache import Cache, LocalCache
 from ..chunker import has_seek_hole
 from ..constants import *  # NOQA
@@ -43,6 +43,7 @@ from ..helpers import Manifest, MandatoryFeatureUnsupported
 from ..helpers import EXIT_SUCCESS, EXIT_WARNING, EXIT_ERROR
 from ..helpers import bin_to_hex
 from ..helpers import msgpack
+from ..helpers import parse_storage_quota
 from ..helpers import flags_noatime, flags_normal
 from ..nanorst import RstToTextLazy, rst_to_terminal
 from ..patterns import IECommand, PatternMatcher, parse_pattern

From a31332ddb5cbabe8d1630989c8ba092e7f2d429d Mon Sep 17 00:00:00 2001
From: Thomas Waldmann <tw@waldmann-edv.de>
Date: Sat, 9 Jul 2022 00:52:54 +0200
Subject: [PATCH 133/160] move rdelete command to archiver.rdelete

---
 setup.cfg                     |   1 +
 src/borg/archiver/__init__.py | 130 ++-----------------------------
 src/borg/archiver/rdelete.py  | 141 ++++++++++++++++++++++++++++++++++
 3 files changed, 148 insertions(+), 124 deletions(-)
 create mode 100644 src/borg/archiver/rdelete.py

diff --git a/setup.cfg b/setup.cfg
index 5c78cde38..3b57bf2eb 100644
--- a/setup.cfg
+++ b/setup.cfg
@@ -125,6 +125,7 @@ per_file_ignores =
     src/borg/archiver/help.py:E501,F405
     src/borg/archiver/keys.py:F405
     src/borg/archiver/prune.py:F405
+    src/borg/archiver/rdelete.py:F405
     src/borg/archiver/tar.py:F405
     src/borg/cache.py:E127,E128,E402,E501,E722,W504
     src/borg/fuse.py:E402,E501,E722,W504
diff --git a/src/borg/archiver/__init__.py b/src/borg/archiver/__init__.py
index 8f3ca5267..2b501c48f 100644
--- a/src/borg/archiver/__init__.py
+++ b/src/borg/archiver/__init__.py
@@ -31,11 +31,11 @@ try:
     from ..archive import Archive, ArchiveRecreater, Statistics, is_special
     from ..archive import BackupError, BackupOSError, backup_io, OsOpen, stat_update_check
     from ..archive import FilesystemObjectProcessors, MetadataCollector, ChunksProcessor
-    from ..cache import Cache, SecurityManager
+    from ..cache import Cache
     from ..constants import *  # NOQA
     from ..compress import CompressionSpec
     from ..helpers import EXIT_SUCCESS, EXIT_WARNING, EXIT_ERROR, EXIT_SIGNAL_BASE
-    from ..helpers import Error, NoManifestError, set_ec
+    from ..helpers import Error, set_ec
     from ..helpers import location_validator, archivename_validator, ChunkerParams, Location
     from ..helpers import NameSpec, CommentSpec, FilesCacheMode
     from ..helpers import BaseFormatter, ItemFormatter, ArchiveFormatter
@@ -46,7 +46,7 @@ try:
     from ..helpers import Manifest
     from ..helpers import HardLinkManager
     from ..helpers import check_python, check_extension_modules
-    from ..helpers import dir_is_tagged, is_slow_msgpack, is_supported_msgpack, yes, sysinfo
+    from ..helpers import dir_is_tagged, is_slow_msgpack, is_supported_msgpack, sysinfo
     from ..helpers import log_multi
     from ..helpers import signal_handler, raising_signal_handler, SigHup, SigTerm
     from ..helpers import ErrorIgnoringTextIOWrapper
@@ -100,6 +100,7 @@ from .locks import LocksMixIn
 from .mount import MountMixIn
 from .prune import PruneMixIn
 from .rcreate import RCreateMixIn
+from .rdelete import RDeleteMixIn
 from .serve import ServeMixIn
 from .tar import TarMixIn
 from .transfer import TransferMixIn
@@ -119,6 +120,7 @@ class Archiver(
     PruneMixIn,
     HelpMixIn,
     RCreateMixIn,
+    RDeleteMixIn,
     ServeMixIn,
     TransferMixIn,
 ):
@@ -703,80 +705,6 @@ class Archiver(
         cache.commit()
         return self.exit_code
 
-    @with_repository(exclusive=True, manifest=False)
-    def do_rdelete(self, args, repository):
-        """Delete a repository"""
-        self.output_list = args.output_list
-        dry_run = args.dry_run
-        keep_security_info = args.keep_security_info
-
-        if not args.cache_only:
-            if args.forced == 0:  # without --force, we let the user see the archives list and confirm.
-                id = bin_to_hex(repository.id)
-                location = repository._location.canonical_path()
-                msg = []
-                try:
-                    manifest, key = Manifest.load(repository, Manifest.NO_OPERATION_CHECK)
-                    n_archives = len(manifest.archives)
-                    msg.append(
-                        f"You requested to completely DELETE the following repository "
-                        f"*including* {n_archives} archives it contains:"
-                    )
-                except NoManifestError:
-                    n_archives = None
-                    msg.append(
-                        "You requested to completely DELETE the following repository "
-                        "*including* all archives it may contain:"
-                    )
-
-                msg.append(DASHES)
-                msg.append(f"Repository ID: {id}")
-                msg.append(f"Location: {location}")
-
-                if self.output_list:
-                    msg.append("")
-                    msg.append("Archives:")
-
-                    if n_archives is not None:
-                        if n_archives > 0:
-                            for archive_info in manifest.archives.list(sort_by=["ts"]):
-                                msg.append(format_archive(archive_info))
-                        else:
-                            msg.append("This repository seems to not have any archives.")
-                    else:
-                        msg.append(
-                            "This repository seems to have no manifest, so we can't "
-                            "tell anything about its contents."
-                        )
-
-                msg.append(DASHES)
-                msg.append("Type 'YES' if you understand this and want to continue: ")
-                msg = "\n".join(msg)
-                if not yes(
-                    msg,
-                    false_msg="Aborting.",
-                    invalid_msg="Invalid answer, aborting.",
-                    truish=("YES",),
-                    retry=False,
-                    env_var_override="BORG_DELETE_I_KNOW_WHAT_I_AM_DOING",
-                ):
-                    self.exit_code = EXIT_ERROR
-                    return self.exit_code
-            if not dry_run:
-                repository.destroy()
-                logger.info("Repository deleted.")
-                if not keep_security_info:
-                    SecurityManager.destroy(repository)
-            else:
-                logger.info("Would delete repository.")
-                logger.info("Would %s security info." % ("keep" if keep_security_info else "delete"))
-        if not dry_run:
-            Cache.destroy(repository)
-            logger.info("Cache deleted.")
-        else:
-            logger.info("Would delete cache.")
-        return self.exit_code
-
     @with_repository(exclusive=True, manifest=False)
     def do_delete(self, args, repository):
         """Delete archives"""
@@ -1753,53 +1681,7 @@ class Archiver(
         self.build_parser_config(subparsers, common_parser, mid_common_parser)
         self.build_parser_debug(subparsers, common_parser, mid_common_parser)
         self.build_parser_help(subparsers, common_parser, mid_common_parser, parser)
-
-        # borg rdelete
-        rdelete_epilog = process_epilog(
-            """
-        This command deletes the complete repository.
-
-        When you delete a complete repository, the security info and local cache for it
-        (if any) are also deleted. Alternatively, you can delete just the local cache
-        with the ``--cache-only`` option, or keep the security info with the
-        ``--keep-security-info`` option.
-
-        Always first use ``--dry-run --list`` to see what would be deleted.
-        """
-        )
-        subparser = subparsers.add_parser(
-            "rdelete",
-            parents=[common_parser],
-            add_help=False,
-            description=self.do_rdelete.__doc__,
-            epilog=rdelete_epilog,
-            formatter_class=argparse.RawDescriptionHelpFormatter,
-            help="delete repository",
-        )
-        subparser.set_defaults(func=self.do_rdelete)
-        subparser.add_argument("-n", "--dry-run", dest="dry_run", action="store_true", help="do not change repository")
-        subparser.add_argument(
-            "--list", dest="output_list", action="store_true", help="output verbose list of archives"
-        )
-        subparser.add_argument(
-            "--force",
-            dest="forced",
-            action="count",
-            default=0,
-            help="force deletion of corrupted archives, " "use ``--force --force`` in case ``--force`` does not work.",
-        )
-        subparser.add_argument(
-            "--cache-only",
-            dest="cache_only",
-            action="store_true",
-            help="delete only the local cache for the given repository",
-        )
-        subparser.add_argument(
-            "--keep-security-info",
-            dest="keep_security_info",
-            action="store_true",
-            help="keep the local security info when deleting a repository",
-        )
+        self.build_parser_rdelete(subparsers, common_parser, mid_common_parser, parser)
 
         # borg delete
         delete_epilog = process_epilog(
diff --git a/src/borg/archiver/rdelete.py b/src/borg/archiver/rdelete.py
new file mode 100644
index 000000000..8a1a4e150
--- /dev/null
+++ b/src/borg/archiver/rdelete.py
@@ -0,0 +1,141 @@
+import argparse
+
+from .common import with_repository
+from ..cache import Cache, SecurityManager
+from ..constants import *  # NOQA
+from ..helpers import EXIT_ERROR
+from ..helpers import NoManifestError
+from ..helpers import format_archive
+from ..helpers import bin_to_hex
+from ..helpers import Manifest
+from ..helpers import yes
+
+from ..logger import create_logger
+
+logger = create_logger()
+
+
+class RDeleteMixIn:
+    @with_repository(exclusive=True, manifest=False)
+    def do_rdelete(self, args, repository):
+        """Delete a repository"""
+        self.output_list = args.output_list
+        dry_run = args.dry_run
+        keep_security_info = args.keep_security_info
+
+        if not args.cache_only:
+            if args.forced == 0:  # without --force, we let the user see the archives list and confirm.
+                id = bin_to_hex(repository.id)
+                location = repository._location.canonical_path()
+                msg = []
+                try:
+                    manifest, key = Manifest.load(repository, Manifest.NO_OPERATION_CHECK)
+                    n_archives = len(manifest.archives)
+                    msg.append(
+                        f"You requested to completely DELETE the following repository "
+                        f"*including* {n_archives} archives it contains:"
+                    )
+                except NoManifestError:
+                    n_archives = None
+                    msg.append(
+                        "You requested to completely DELETE the following repository "
+                        "*including* all archives it may contain:"
+                    )
+
+                msg.append(DASHES)
+                msg.append(f"Repository ID: {id}")
+                msg.append(f"Location: {location}")
+
+                if self.output_list:
+                    msg.append("")
+                    msg.append("Archives:")
+
+                    if n_archives is not None:
+                        if n_archives > 0:
+                            for archive_info in manifest.archives.list(sort_by=["ts"]):
+                                msg.append(format_archive(archive_info))
+                        else:
+                            msg.append("This repository seems to not have any archives.")
+                    else:
+                        msg.append(
+                            "This repository seems to have no manifest, so we can't "
+                            "tell anything about its contents."
+                        )
+
+                msg.append(DASHES)
+                msg.append("Type 'YES' if you understand this and want to continue: ")
+                msg = "\n".join(msg)
+                if not yes(
+                    msg,
+                    false_msg="Aborting.",
+                    invalid_msg="Invalid answer, aborting.",
+                    truish=("YES",),
+                    retry=False,
+                    env_var_override="BORG_DELETE_I_KNOW_WHAT_I_AM_DOING",
+                ):
+                    self.exit_code = EXIT_ERROR
+                    return self.exit_code
+            if not dry_run:
+                repository.destroy()
+                logger.info("Repository deleted.")
+                if not keep_security_info:
+                    SecurityManager.destroy(repository)
+            else:
+                logger.info("Would delete repository.")
+                logger.info("Would %s security info." % ("keep" if keep_security_info else "delete"))
+        if not dry_run:
+            Cache.destroy(repository)
+            logger.info("Cache deleted.")
+        else:
+            logger.info("Would delete cache.")
+        return self.exit_code
+
+    def build_parser_rdelete(self, subparsers, common_parser, mid_common_parser, parser):
+
+        from .common import process_epilog
+
+        rdelete_epilog = process_epilog(
+            """
+        This command deletes the complete repository.
+
+        When you delete a complete repository, the security info and local cache for it
+        (if any) are also deleted. Alternatively, you can delete just the local cache
+        with the ``--cache-only`` option, or keep the security info with the
+        ``--keep-security-info`` option.
+
+        Always first use ``--dry-run --list`` to see what would be deleted.
+        """
+        )
+        subparser = subparsers.add_parser(
+            "rdelete",
+            parents=[common_parser],
+            add_help=False,
+            description=self.do_rdelete.__doc__,
+            epilog=rdelete_epilog,
+            formatter_class=argparse.RawDescriptionHelpFormatter,
+            help="delete repository",
+        )
+        subparser.set_defaults(func=self.do_rdelete)
+        subparser.add_argument("-n", "--dry-run", dest="dry_run", action="store_true", help="do not change repository")
+        subparser.add_argument(
+            "--list", dest="output_list", action="store_true", help="output verbose list of archives"
+        )
+        subparser.add_argument(
+            "--force",
+            dest="forced",
+            action="count",
+            default=0,
+            help="force deletion of corrupted archives, " "use ``--force --force`` in case ``--force`` does not work.",
+        )
+        subparser.add_argument(
+            "--cache-only",
+            dest="cache_only",
+            action="store_true",
+            help="delete only the local cache for the given repository",
+        )
+        subparser.add_argument(
+            "--keep-security-info",
+            dest="keep_security_info",
+            action="store_true",
+            help="keep the local security info when deleting a repository",
+        )

From 06fe8d3e64d2096d1936c8cdde779a65dd4264c3 Mon Sep 17 00:00:00 2001
From: Thomas Waldmann <tw@waldmann-edv.de>
Date: Sat, 9 Jul 2022 00:58:05 +0200
Subject: [PATCH 134/160] move rename command to archiver.rename

---
 src/borg/archiver/__init__.py | 36 +++------------------------
 src/borg/archiver/rename.py   | 47 +++++++++++++++++++++++++++++++++++
 2 files changed, 50 insertions(+), 33 deletions(-)
 create mode 100644 src/borg/archiver/rename.py

diff --git a/src/borg/archiver/__init__.py b/src/borg/archiver/__init__.py
index 2b501c48f..c27c1f12f 100644
--- a/src/borg/archiver/__init__.py
+++ b/src/borg/archiver/__init__.py
@@ -99,6 +99,7 @@ from .keys import KeysMixIn
 from .locks import LocksMixIn
 from .mount import MountMixIn
 from .prune import PruneMixIn
+from .rename import RenameMixIn
 from .rcreate import RCreateMixIn
 from .rdelete import RDeleteMixIn
 from .serve import ServeMixIn
@@ -119,6 +120,7 @@ class Archiver(
     MountMixIn,
     PruneMixIn,
     HelpMixIn,
+    RenameMixIn,
     RCreateMixIn,
     RDeleteMixIn,
     ServeMixIn,
@@ -695,16 +697,6 @@ class Archiver(
             pi.finish()
         return self.exit_code
 
-    @with_repository(exclusive=True, cache=True, compatibility=(Manifest.Operation.CHECK,))
-    @with_archive
-    def do_rename(self, args, repository, manifest, key, cache, archive):
-        """Rename an existing archive"""
-        archive.rename(args.newname)
-        manifest.write()
-        repository.commit(compact=False)
-        cache.commit()
-        return self.exit_code
-
     @with_repository(exclusive=True, manifest=False)
     def do_delete(self, args, repository):
         """Delete archives"""
@@ -2202,29 +2194,7 @@ class Archiver(
             "paths", metavar="PATH", nargs="*", type=str, help="paths to recreate; patterns are supported"
         )
 
-        # borg rename
-        rename_epilog = process_epilog(
-            """
-        This command renames an archive in the repository.
-
-        This results in a different archive ID.
-        """
-        )
-        subparser = subparsers.add_parser(
-            "rename",
-            parents=[common_parser],
-            add_help=False,
-            description=self.do_rename.__doc__,
-            epilog=rename_epilog,
-            formatter_class=argparse.RawDescriptionHelpFormatter,
-            help="rename archive",
-        )
-        subparser.set_defaults(func=self.do_rename)
-        subparser.add_argument("name", metavar="OLDNAME", type=archivename_validator(), help="specify the archive name")
-        subparser.add_argument(
-            "newname", metavar="NEWNAME", type=archivename_validator(), help="specify the new archive name"
-        )
-
+        self.build_parser_rename(subparsers, common_parser, mid_common_parser)
         self.build_parser_serve(subparsers, common_parser, mid_common_parser)
         self.build_parser_tar(subparsers, common_parser, mid_common_parser)
 
diff --git a/src/borg/archiver/rename.py b/src/borg/archiver/rename.py
new file mode 100644
index 000000000..9122e5a23
--- /dev/null
+++ b/src/borg/archiver/rename.py
@@ -0,0 +1,47 @@
+import argparse
+
+from .common import with_repository, with_archive
+from ..constants import *  # NOQA
+from ..helpers import archivename_validator
+from ..helpers import Manifest
+
+from ..logger import create_logger
+
+logger = create_logger()
+
+
+class RenameMixIn:
+    @with_repository(exclusive=True, cache=True, compatibility=(Manifest.Operation.CHECK,))
+    @with_archive
+    def do_rename(self, args, repository, manifest, key, cache, archive):
+        """Rename an existing archive"""
+        archive.rename(args.newname)
+        manifest.write()
+        repository.commit(compact=False)
+        cache.commit()
+        return self.exit_code
+
+    def build_parser_rename(self, subparsers, common_parser, mid_common_parser):
+        from .common import process_epilog
+
+        rename_epilog = process_epilog(
+            """
+        This command renames an archive in the repository.
+
+        This results in a different archive ID.
+        """
+        )
+        subparser = subparsers.add_parser(
+            "rename",
+            parents=[common_parser],
+            add_help=False,
+            description=self.do_rename.__doc__,
+            epilog=rename_epilog,
+            formatter_class=argparse.RawDescriptionHelpFormatter,
+            help="rename archive",
+        )
+        subparser.set_defaults(func=self.do_rename)
+        subparser.add_argument("name", metavar="OLDNAME", type=archivename_validator(), help="specify the archive name")
+        subparser.add_argument(
+            "newname", metavar="NEWNAME", type=archivename_validator(), help="specify the new archive name"
+        )

From 350a8fe252fc7b1397482e22082f3d76a15bbd13 Mon Sep 17 00:00:00 2001
From: Thomas Waldmann <tw@waldmann-edv.de>
Date: Sat, 9 Jul 2022 01:08:39 +0200
Subject: [PATCH 135/160] move delete command to archiver.delete

---
 setup.cfg                     |   1 +
 src/borg/archiver/__init__.py | 153 ++-----------------------------
 src/borg/archiver/delete.py   | 163 ++++++++++++++++++++++++++++++++++
 3 files changed, 169 insertions(+), 148 deletions(-)
 create mode 100644 src/borg/archiver/delete.py

diff --git a/setup.cfg b/setup.cfg
index 3b57bf2eb..4316af2a7 100644
--- a/setup.cfg
+++ b/setup.cfg
@@ -121,6 +121,7 @@ per_file_ignores =
     src/borg/archiver/config.py:F405,E722
     src/borg/archiver/common.py:E501,F405
     src/borg/archiver/debug.py:F405
+    src/borg/archiver/delete.py:F405
     src/borg/archiver/diff.py:F405
     src/borg/archiver/help.py:E501,F405
     src/borg/archiver/keys.py:F405
diff --git a/src/borg/archiver/__init__.py b/src/borg/archiver/__init__.py
index c27c1f12f..e96c4048b 100644
--- a/src/borg/archiver/__init__.py
+++ b/src/borg/archiver/__init__.py
@@ -28,7 +28,7 @@ try:
     from .common import with_repository, with_archive, Highlander
     from .. import __version__
     from .. import helpers
-    from ..archive import Archive, ArchiveRecreater, Statistics, is_special
+    from ..archive import Archive, ArchiveRecreater, is_special
     from ..archive import BackupError, BackupOSError, backup_io, OsOpen, stat_update_check
     from ..archive import FilesystemObjectProcessors, MetadataCollector, ChunksProcessor
     from ..cache import Cache
@@ -39,7 +39,7 @@ try:
     from ..helpers import location_validator, archivename_validator, ChunkerParams, Location
     from ..helpers import NameSpec, CommentSpec, FilesCacheMode
     from ..helpers import BaseFormatter, ItemFormatter, ArchiveFormatter
-    from ..helpers import format_timedelta, format_file_size, format_archive
+    from ..helpers import format_timedelta, format_file_size
     from ..helpers import remove_surrogates, bin_to_hex, eval_escapes
     from ..helpers import timestamp
     from ..helpers import get_cache_dir, os_stat
@@ -93,6 +93,7 @@ from .check import CheckMixIn
 from .compact import CompactMixIn
 from .config import ConfigMixIn
 from .debug import DebugMixIn
+from .delete import DeleteMixIn
 from .diff import DiffMixIn
 from .help import HelpMixIn
 from .keys import KeysMixIn
@@ -112,6 +113,7 @@ class Archiver(
     ConfigMixIn,
     CompactMixIn,
     DebugMixIn,
+    DeleteMixIn,
     DiffMixIn,
     TarMixIn,
     BenchmarkMixIn,
@@ -697,83 +699,6 @@ class Archiver(
             pi.finish()
         return self.exit_code
 
-    @with_repository(exclusive=True, manifest=False)
-    def do_delete(self, args, repository):
-        """Delete archives"""
-        self.output_list = args.output_list
-        dry_run = args.dry_run
-        manifest, key = Manifest.load(repository, (Manifest.Operation.DELETE,))
-        archive_names = tuple(x.name for x in manifest.archives.list_considering(args))
-        if not archive_names:
-            return self.exit_code
-        if args.glob_archives is None and args.first == 0 and args.last == 0:
-            self.print_error(
-                "Aborting: if you really want to delete all archives, please use -a '*' "
-                "or just delete the whole repository (might be much faster)."
-            )
-            return EXIT_ERROR
-
-        if args.forced == 2:
-            deleted = False
-            logger_list = logging.getLogger("borg.output.list")
-            for i, archive_name in enumerate(archive_names, 1):
-                try:
-                    current_archive = manifest.archives.pop(archive_name)
-                except KeyError:
-                    self.exit_code = EXIT_WARNING
-                    logger.warning(f"Archive {archive_name} not found ({i}/{len(archive_names)}).")
-                else:
-                    deleted = True
-                    if self.output_list:
-                        msg = "Would delete: {} ({}/{})" if dry_run else "Deleted archive: {} ({}/{})"
-                        logger_list.info(msg.format(format_archive(current_archive), i, len(archive_names)))
-            if dry_run:
-                logger.info("Finished dry-run.")
-            elif deleted:
-                manifest.write()
-                # note: might crash in compact() after committing the repo
-                repository.commit(compact=False)
-                logger.warning('Done. Run "borg check --repair" to clean up the mess.')
-            else:
-                logger.warning("Aborted.")
-            return self.exit_code
-
-        stats = Statistics(iec=args.iec)
-        with Cache(repository, key, manifest, progress=args.progress, lock_wait=self.lock_wait, iec=args.iec) as cache:
-            msg_delete = "Would delete archive: {} ({}/{})" if dry_run else "Deleting archive: {} ({}/{})"
-            msg_not_found = "Archive {} not found ({}/{})."
-            logger_list = logging.getLogger("borg.output.list")
-            delete_count = 0
-            for i, archive_name in enumerate(archive_names, 1):
-                try:
-                    archive_info = manifest.archives[archive_name]
-                except KeyError:
-                    logger.warning(msg_not_found.format(archive_name, i, len(archive_names)))
-                else:
-                    if self.output_list:
-                        logger_list.info(msg_delete.format(format_archive(archive_info), i, len(archive_names)))
-
-                    if not dry_run:
-                        archive = Archive(
-                            repository,
-                            key,
-                            manifest,
-                            archive_name,
-                            cache=cache,
-                            consider_part_files=args.consider_part_files,
-                        )
-                        archive.delete(stats, progress=args.progress, forced=args.forced)
-                        delete_count += 1
-            if delete_count > 0:
-                # only write/commit if we actually changed something, see #6060.
-                manifest.write()
-                repository.commit(compact=False, save_space=args.save_space)
-                cache.commit()
-            if args.stats:
-                log_multi(str(stats), logger=logging.getLogger("borg.output.stats"))
-
-        return self.exit_code
-
     @with_repository(compatibility=(Manifest.Operation.READ,))
     def do_list(self, args, repository, manifest, key):
         """List archive contents"""
@@ -1672,78 +1597,10 @@ class Archiver(
 
         self.build_parser_config(subparsers, common_parser, mid_common_parser)
         self.build_parser_debug(subparsers, common_parser, mid_common_parser)
+        self.build_parser_delete(subparsers, common_parser, mid_common_parser)
         self.build_parser_help(subparsers, common_parser, mid_common_parser, parser)
         self.build_parser_rdelete(subparsers, common_parser, mid_common_parser, parser)
 
-        # borg delete
-        delete_epilog = process_epilog(
-            """
-        This command deletes archives from the repository.
-
-        Important: When deleting archives, repository disk space is **not** freed until
-        you run ``borg compact``.
-
-        When in doubt, use ``--dry-run --list`` to see what would be deleted.
-
-        When using ``--stats``, you will get some statistics about how much data was
-        deleted - the "Deleted data" deduplicated size there is most interesting as
-        that is how much your repository will shrink.
-        Please note that the "All archives" stats refer to the state after deletion.
-
-        You can delete multiple archives by specifying a matching shell pattern,
-        using the ``--glob-archives GLOB`` option (for more info on these patterns,
-        see :ref:`borg_patterns`).
-
-        Always first use ``--dry-run --list`` to see what would be deleted.
-        """
-        )
-        subparser = subparsers.add_parser(
-            "delete",
-            parents=[common_parser],
-            add_help=False,
-            description=self.do_delete.__doc__,
-            epilog=delete_epilog,
-            formatter_class=argparse.RawDescriptionHelpFormatter,
-            help="delete archive",
-        )
-        subparser.set_defaults(func=self.do_delete)
-        subparser.add_argument("-n", "--dry-run", dest="dry_run", action="store_true", help="do not change repository")
-        subparser.add_argument(
-            "--list", dest="output_list", action="store_true", help="output verbose list of archives"
-        )
-        subparser.add_argument(
-            "--consider-checkpoints",
-            action="store_true",
-            dest="consider_checkpoints",
-            help="consider checkpoint archives for deletion (default: not considered).",
-        )
-        subparser.add_argument(
-            "-s", "--stats", dest="stats", action="store_true", help="print statistics for the deleted archive"
-        )
-        subparser.add_argument(
-            "--cache-only",
-            dest="cache_only",
-            action="store_true",
-            help="delete only the local cache for the given repository",
-        )
-        subparser.add_argument(
-            "--force",
-            dest="forced",
-            action="count",
-            default=0,
-            help="force deletion of corrupted archives, " "use ``--force --force`` in case ``--force`` does not work.",
-        )
-        subparser.add_argument(
-            "--keep-security-info",
-            dest="keep_security_info",
-            action="store_true",
-            help="keep the local security info when deleting a repository",
-        )
-        subparser.add_argument(
-            "--save-space", dest="save_space", action="store_true", help="work slower, but using less space"
-        )
-        define_archive_filters_group(subparser)
-
         # borg extract
         extract_epilog = process_epilog(
             """
diff --git a/src/borg/archiver/delete.py b/src/borg/archiver/delete.py
new file mode 100644
index 000000000..3983b5a51
--- /dev/null
+++ b/src/borg/archiver/delete.py
@@ -0,0 +1,163 @@
+import argparse
+import logging
+
+from .common import with_repository
+from ..archive import Archive, Statistics
+from ..cache import Cache
+from ..constants import *  # NOQA
+from ..helpers import Manifest
+from ..helpers import log_multi, format_archive
+
+from ..logger import create_logger
+
+logger = create_logger()
+
+
+class DeleteMixIn:
+    @with_repository(exclusive=True, manifest=False)
+    def do_delete(self, args, repository):
+        """Delete archives"""
+        self.output_list = args.output_list
+        dry_run = args.dry_run
+        manifest, key = Manifest.load(repository, (Manifest.Operation.DELETE,))
+        archive_names = tuple(x.name for x in manifest.archives.list_considering(args))
+        if not archive_names:
+            return self.exit_code
+        if args.glob_archives is None and args.first == 0 and args.last == 0:
+            self.print_error(
+                "Aborting: if you really want to delete all archives, please use -a '*' "
+                "or just delete the whole repository (might be much faster)."
+            )
+            return EXIT_ERROR
+
+        if args.forced == 2:
+            deleted = False
+            logger_list = logging.getLogger("borg.output.list")
+            for i, archive_name in enumerate(archive_names, 1):
+                try:
+                    current_archive = manifest.archives.pop(archive_name)
+                except KeyError:
+                    self.exit_code = EXIT_WARNING
+                    logger.warning(f"Archive {archive_name} not found ({i}/{len(archive_names)}).")
+                else:
+                    deleted = True
+                    if self.output_list:
+                        msg = "Would delete: {} ({}/{})" if dry_run else "Deleted archive: {} ({}/{})"
+                        logger_list.info(msg.format(format_archive(current_archive), i, len(archive_names)))
+            if dry_run:
+                logger.info("Finished dry-run.")
+            elif deleted:
+                manifest.write()
+                # note: might crash in compact() after committing the repo
+                repository.commit(compact=False)
+                logger.warning('Done. Run "borg check --repair" to clean up the mess.')
+            else:
+                logger.warning("Aborted.")
+            return self.exit_code
+
+        stats = Statistics(iec=args.iec)
+        with Cache(repository, key, manifest, progress=args.progress, lock_wait=self.lock_wait, iec=args.iec) as cache:
+            msg_delete = "Would delete archive: {} ({}/{})" if dry_run else "Deleting archive: {} ({}/{})"
+            msg_not_found = "Archive {} not found ({}/{})."
+            logger_list = logging.getLogger("borg.output.list")
+            delete_count = 0
+            for i, archive_name in enumerate(archive_names, 1):
+                try:
+                    archive_info = manifest.archives[archive_name]
+                except KeyError:
+                    logger.warning(msg_not_found.format(archive_name, i, len(archive_names)))
+                else:
+                    if self.output_list:
+                        logger_list.info(msg_delete.format(format_archive(archive_info), i, len(archive_names)))
+
+                    if not dry_run:
+                        archive = Archive(
+                            repository,
+                            key,
+                            manifest,
+                            archive_name,
+                            cache=cache,
+                            consider_part_files=args.consider_part_files,
+                        )
+                        archive.delete(stats, progress=args.progress, forced=args.forced)
+                        delete_count += 1
+            if delete_count > 0:
+                # only write/commit if we actually changed something, see #6060.
+                manifest.write()
+                repository.commit(compact=False, save_space=args.save_space)
+                cache.commit()
+            if args.stats:
+                log_multi(str(stats), logger=logging.getLogger("borg.output.stats"))
+
+        return self.exit_code
+
+    def build_parser_delete(self, subparsers, common_parser, mid_common_parser):
+        from .common import process_epilog, define_archive_filters_group
+
+        delete_epilog = process_epilog(
+            """
+        This command deletes archives from the repository.
+
+        Important: When deleting archives, repository disk space is **not** freed until
+        you run ``borg compact``.
+
+        When in doubt, use ``--dry-run --list`` to see what would be deleted.
+
+        When using ``--stats``, you will get some statistics about how much data was
+        deleted - the "Deleted data" deduplicated size there is most interesting as
+        that is how much your repository will shrink.
+        Please note that the "All archives" stats refer to the state after deletion.
+
+        You can delete multiple archives by specifying a matching shell pattern,
+        using the ``--glob-archives GLOB`` option (for more info on these patterns,
+        see :ref:`borg_patterns`).
+
+        Always first use ``--dry-run --list`` to see what would be deleted.
+        """
+        )
+        subparser = subparsers.add_parser(
+            "delete",
+            parents=[common_parser],
+            add_help=False,
+            description=self.do_delete.__doc__,
+            epilog=delete_epilog,
+            formatter_class=argparse.RawDescriptionHelpFormatter,
+            help="delete archive",
+        )
+        subparser.set_defaults(func=self.do_delete)
+        subparser.add_argument("-n", "--dry-run", dest="dry_run", action="store_true", help="do not change repository")
+        subparser.add_argument(
+            "--list", dest="output_list", action="store_true", help="output verbose list of archives"
+        )
+        subparser.add_argument(
+            "--consider-checkpoints",
+            action="store_true",
+            dest="consider_checkpoints",
+            help="consider checkpoint archives for deletion (default: not considered).",
+        )
+        subparser.add_argument(
+            "-s", "--stats", dest="stats", action="store_true", help="print statistics for the deleted archive"
+        )
+        subparser.add_argument(
+            "--cache-only",
+            dest="cache_only",
+            action="store_true",
+            help="delete only the local cache for the given repository",
+        )
+        subparser.add_argument(
+            "--force",
+            dest="forced",
+            action="count",
+            default=0,
+            help="force deletion of corrupted archives, " "use ``--force --force`` in case ``--force`` does not work.",
+        )
+        subparser.add_argument(
+            "--keep-security-info",
+            dest="keep_security_info",
+            action="store_true",
+            help="keep the local security info when deleting a repository",
+        )
+        subparser.add_argument(
+            "--save-space", dest="save_space", action="store_true", help="work slower, but using less space"
+        )
+        define_archive_filters_group(subparser)

From 382b37ef604cf621488594d9df1e27d72833c2a1 Mon Sep 17 00:00:00 2001
From: Thomas Waldmann <tw@waldmann-edv.de>
Date: Sat, 9 Jul 2022 01:15:59 +0200
Subject: [PATCH 136/160] move list command to archiver.list

---
 src/borg/archiver/__init__.py | 113 ++----------------------------
 src/borg/archiver/list.py     | 126 ++++++++++++++++++++++++++++++++++
 2 files changed, 130 insertions(+), 109 deletions(-)
 create mode 100644 src/borg/archiver/list.py

diff --git a/src/borg/archiver/__init__.py b/src/borg/archiver/__init__.py
index e96c4048b..cb9e57c51 100644
--- a/src/borg/archiver/__init__.py
+++ b/src/borg/archiver/__init__.py
@@ -38,7 +38,7 @@ try:
     from ..helpers import Error, set_ec
     from ..helpers import location_validator, archivename_validator, ChunkerParams, Location
     from ..helpers import NameSpec, CommentSpec, FilesCacheMode
-    from ..helpers import BaseFormatter, ItemFormatter, ArchiveFormatter
+    from ..helpers import BaseFormatter, ArchiveFormatter
     from ..helpers import format_timedelta, format_file_size
     from ..helpers import remove_surrogates, bin_to_hex, eval_escapes
     from ..helpers import timestamp
@@ -97,6 +97,7 @@ from .delete import DeleteMixIn
 from .diff import DiffMixIn
 from .help import HelpMixIn
 from .keys import KeysMixIn
+from .list import ListMixIn
 from .locks import LocksMixIn
 from .mount import MountMixIn
 from .prune import PruneMixIn
@@ -118,6 +119,7 @@ class Archiver(
     TarMixIn,
     BenchmarkMixIn,
     KeysMixIn,
+    ListMixIn,
     LocksMixIn,
     MountMixIn,
     PruneMixIn,
@@ -699,35 +701,6 @@ class Archiver(
             pi.finish()
         return self.exit_code
 
-    @with_repository(compatibility=(Manifest.Operation.READ,))
-    def do_list(self, args, repository, manifest, key):
-        """List archive contents"""
-        matcher = self.build_matcher(args.patterns, args.paths)
-        if args.format is not None:
-            format = args.format
-        elif args.short:
-            format = "{path}{NL}"
-        else:
-            format = "{mode} {user:6} {group:6} {size:8} {mtime} {path}{extra}{NL}"
-
-        def _list_inner(cache):
-            archive = Archive(
-                repository, key, manifest, args.name, cache=cache, consider_part_files=args.consider_part_files
-            )
-
-            formatter = ItemFormatter(archive, format, json_lines=args.json_lines)
-            for item in archive.iter_items(lambda item: matcher.match(item.path)):
-                sys.stdout.write(formatter.format_item(item))
-
-        # Only load the cache if it will be used
-        if ItemFormatter.format_needs_cache(format):
-            with Cache(repository, key, manifest, lock_wait=self.lock_wait) as cache:
-                _list_inner(cache)
-        else:
-            _list_inner(cache=None)
-
-        return self.exit_code
-
     @with_repository(compatibility=(Manifest.Operation.READ,))
     def do_rlist(self, args, repository, manifest, key):
         """List the archives contained in a repository"""
@@ -1210,6 +1183,7 @@ class Archiver(
         self.build_parser_check(subparsers, common_parser, mid_common_parser)
         self.build_parser_compact(subparsers, common_parser, mid_common_parser)
         self.build_parser_diff(subparsers, common_parser, mid_common_parser)
+        self.build_parser_list(subparsers, common_parser, mid_common_parser)
         self.build_parser_locks(subparsers, common_parser, mid_common_parser)
         self.build_parser_mount_umount(subparsers, common_parser, mid_common_parser)
         self.build_parser_prune(subparsers, common_parser, mid_common_parser)
@@ -1733,85 +1707,6 @@ class Archiver(
         self.build_parser_keys(subparsers, common_parser, mid_common_parser)
         self.build_parser_rcreate(subparsers, common_parser, mid_common_parser)
 
-        # borg list
-        list_epilog = (
-            process_epilog(
-                """
-        This command lists the contents of an archive.
-
-        For more help on include/exclude patterns, see the :ref:`borg_patterns` command output.
-
-        .. man NOTES
-
-        The FORMAT specifier syntax
-        +++++++++++++++++++++++++++
-
-        The ``--format`` option uses python's `format string syntax
-        <https://docs.python.org/3.9/library/string.html#formatstrings>`_.
-
-        Examples:
-        ::
-
-            $ borg list --format '{mode} {user:6} {group:6} {size:8} {mtime} {path}{extra}{NL}' ArchiveFoo
-            -rw-rw-r-- user   user       1024 Thu, 2021-12-09 10:22:17 file-foo
-            ...
-
-            # {VAR:<NUMBER} - pad to NUMBER columns left-aligned.
-            # {VAR:>NUMBER} - pad to NUMBER columns right-aligned.
-            $ borg list --format '{mode} {user:>6} {group:>6} {size:<8} {mtime} {path}{extra}{NL}' ArchiveFoo
-            -rw-rw-r--   user   user 1024     Thu, 2021-12-09 10:22:17 file-foo
-            ...
-
-        The following keys are always available:
-
-
-        """
-            )
-            + BaseFormatter.keys_help()
-            + textwrap.dedent(
-                """
-
-        Keys available only when listing files in an archive:
-
-        """
-            )
-            + ItemFormatter.keys_help()
-        )
-        subparser = subparsers.add_parser(
-            "list",
-            parents=[common_parser],
-            add_help=False,
-            description=self.do_list.__doc__,
-            epilog=list_epilog,
-            formatter_class=argparse.RawDescriptionHelpFormatter,
-            help="list archive contents",
-        )
-        subparser.set_defaults(func=self.do_list)
-        subparser.add_argument(
-            "--short", dest="short", action="store_true", help="only print file/directory names, nothing else"
-        )
-        subparser.add_argument(
-            "--format",
-            metavar="FORMAT",
-            dest="format",
-            help="specify format for file listing "
-            '(default: "{mode} {user:6} {group:6} {size:8} {mtime} {path}{extra}{NL}")',
-        )
-        subparser.add_argument(
-            "--json-lines",
-            action="store_true",
-            help="Format output as JSON Lines. "
-            "The form of ``--format`` is ignored, "
-            "but keys used in it are added to the JSON output. "
-            "Some keys are always present. Note: JSON can only represent text. "
-            'A "bpath" key is therefore not available.',
-        )
-        subparser.add_argument("name", metavar="NAME", type=NameSpec, help="specify the archive name")
-        subparser.add_argument(
-            "paths", metavar="PATH", nargs="*", type=str, help="paths to list; patterns are supported"
-        )
-        define_exclusion_group(subparser)
-
         # borg rlist
         rlist_epilog = (
             process_epilog(
diff --git a/src/borg/archiver/list.py b/src/borg/archiver/list.py
new file mode 100644
index 000000000..a48ee2a09
--- /dev/null
+++ b/src/borg/archiver/list.py
@@ -0,0 +1,126 @@
+import argparse
+import textwrap
+import sys
+
+from .common import with_repository
+from ..archive import Archive
+from ..cache import Cache
+from ..constants import *  # NOQA
+from ..helpers import Manifest
+from ..helpers import ItemFormatter, BaseFormatter, NameSpec
+
+from ..logger import create_logger
+
+logger = create_logger()
+
+
+class ListMixIn:
+    @with_repository(compatibility=(Manifest.Operation.READ,))
+    def do_list(self, args, repository, manifest, key):
+        """List archive contents"""
+        matcher = self.build_matcher(args.patterns, args.paths)
+        if args.format is not None:
+            format = args.format
+        elif args.short:
+            format = "{path}{NL}"
+        else:
+            format = "{mode} {user:6} {group:6} {size:8} {mtime} {path}{extra}{NL}"
+
+        def _list_inner(cache):
+            archive = Archive(
+                repository, key, manifest, args.name, cache=cache, consider_part_files=args.consider_part_files
+            )
+
+            formatter = ItemFormatter(archive, format, json_lines=args.json_lines)
+            for item in archive.iter_items(lambda item: matcher.match(item.path)):
+                sys.stdout.write(formatter.format_item(item))
+
+        # Only load the cache if it will be used
+        if ItemFormatter.format_needs_cache(format):
+            with Cache(repository, key, manifest, lock_wait=self.lock_wait) as cache:
+                _list_inner(cache)
+        else:
+            _list_inner(cache=None)
+
+        return self.exit_code
+
+    def build_parser_list(self, subparsers, common_parser, mid_common_parser):
+        from .common import process_epilog, define_exclusion_group
+
+        list_epilog = (
+            process_epilog(
+                """
+        This command lists the contents of an archive.
+
+        For more help on include/exclude patterns, see the :ref:`borg_patterns` command output.
+
+        .. man NOTES
+
+        The FORMAT specifier syntax
+        +++++++++++++++++++++++++++
+
+        The ``--format`` option uses python's `format string syntax
+        <https://docs.python.org/3.9/library/string.html#formatstrings>`_.
+
+        Examples:
+        ::
+
+            $ borg list --format '{mode} {user:6} {group:6} {size:8} {mtime} {path}{extra}{NL}' ArchiveFoo
+            -rw-rw-r-- user   user       1024 Thu, 2021-12-09 10:22:17 file-foo
+            ...
+
+            # {VAR:<NUMBER} - pad to NUMBER columns left-aligned.
+            # {VAR:>NUMBER} - pad to NUMBER columns right-aligned.
+            $ borg list --format '{mode} {user:>6} {group:>6} {size:<8} {mtime} {path}{extra}{NL}' ArchiveFoo
+            -rw-rw-r--   user   user 1024     Thu, 2021-12-09 10:22:17 file-foo
+            ...
+
+        The following keys are always available:
+
+
+        """
+            )
+            + BaseFormatter.keys_help()
+            + textwrap.dedent(
+                """
+
+        Keys available only when listing files in an archive:
+
+        """
+            )
+            + ItemFormatter.keys_help()
+        )
+        subparser = subparsers.add_parser(
+            "list",
+            parents=[common_parser],
+            add_help=False,
+            description=self.do_list.__doc__,
+            epilog=list_epilog,
+            formatter_class=argparse.RawDescriptionHelpFormatter,
+            help="list archive contents",
+        )
+        subparser.set_defaults(func=self.do_list)
+        subparser.add_argument(
+            "--short", dest="short", action="store_true", help="only print file/directory names, nothing else"
+        )
+        subparser.add_argument(
+            "--format",
+            metavar="FORMAT",
+            dest="format",
+            help="specify format for file listing "
+            '(default: "{mode} {user:6} {group:6} {size:8} {mtime} {path}{extra}{NL}")',
+        )
+        subparser.add_argument(
+            "--json-lines",
+            action="store_true",
+            help="Format output as JSON Lines. "
+            "The form of ``--format`` is ignored, "
+            "but keys used in it are added to the JSON output. "
+            "Some keys are always present. Note: JSON can only represent text. "
+            'A "bpath" key is therefore not available.',
+        )
+        subparser.add_argument("name", metavar="NAME", type=NameSpec, help="specify the archive name")
+        subparser.add_argument(
+            "paths", metavar="PATH", nargs="*", type=str, help="paths to list; patterns are supported"
+        )
+        define_exclusion_group(subparser)

From b959ff913a5cd6def20a243a5f0523c331b4876d Mon Sep 17 00:00:00 2001
From: Thomas Waldmann <tw@waldmann-edv.de>
Date: Sat, 9 Jul 2022 01:25:20 +0200
Subject: [PATCH 137/160] move list command to archiver.list_cmd

note: can't be named "archiver.list" due to collision with builtin type "list".
---
 src/borg/archiver/__init__.py              | 2 +-
 src/borg/archiver/{list.py => list_cmd.py} | 0
 2 files changed, 1 insertion(+), 1 deletion(-)
 rename src/borg/archiver/{list.py => list_cmd.py} (100%)

diff --git a/src/borg/archiver/__init__.py b/src/borg/archiver/__init__.py
index cb9e57c51..f941c4d7a 100644
--- a/src/borg/archiver/__init__.py
+++ b/src/borg/archiver/__init__.py
@@ -97,7 +97,7 @@ from .delete import DeleteMixIn
 from .diff import DiffMixIn
 from .help import HelpMixIn
 from .keys import KeysMixIn
-from .list import ListMixIn
+from .list_cmd import ListMixIn
 from .locks import LocksMixIn
 from .mount import MountMixIn
 from .prune import PruneMixIn
diff --git a/src/borg/archiver/list.py b/src/borg/archiver/list_cmd.py
similarity index 100%
rename from src/borg/archiver/list.py
rename to src/borg/archiver/list_cmd.py

From add73745c6f56d7ea967986612af07c0c6ae344f Mon Sep 17 00:00:00 2001
From: Thomas Waldmann <tw@waldmann-edv.de>
Date: Sat, 9 Jul 2022 01:35:13 +0200
Subject: [PATCH 138/160] move rlist command to archiver.rlist

---
 setup.cfg                     |   1 +
 src/borg/archiver/__init__.py | 108 +-----------------------------
 src/borg/archiver/rlist.py    | 120 ++++++++++++++++++++++++++++++++++
 3 files changed, 124 insertions(+), 105 deletions(-)
 create mode 100644 src/borg/archiver/rlist.py

diff --git a/setup.cfg b/setup.cfg
index 4316af2a7..bf7dbb322 100644
--- a/setup.cfg
+++ b/setup.cfg
@@ -127,6 +127,7 @@ per_file_ignores =
     src/borg/archiver/keys.py:F405
     src/borg/archiver/prune.py:F405
     src/borg/archiver/rdelete.py:F405
+    src/borg/archiver/rlist.py:E501
     src/borg/archiver/tar.py:F405
     src/borg/cache.py:E127,E128,E402,E501,E722,W504
     src/borg/fuse.py:E402,E501,E722,W504
diff --git a/src/borg/archiver/__init__.py b/src/borg/archiver/__init__.py
index f941c4d7a..ef6ca28e1 100644
--- a/src/borg/archiver/__init__.py
+++ b/src/borg/archiver/__init__.py
@@ -38,7 +38,6 @@ try:
     from ..helpers import Error, set_ec
     from ..helpers import location_validator, archivename_validator, ChunkerParams, Location
     from ..helpers import NameSpec, CommentSpec, FilesCacheMode
-    from ..helpers import BaseFormatter, ArchiveFormatter
     from ..helpers import format_timedelta, format_file_size
     from ..helpers import remove_surrogates, bin_to_hex, eval_escapes
     from ..helpers import timestamp
@@ -104,6 +103,7 @@ from .prune import PruneMixIn
 from .rename import RenameMixIn
 from .rcreate import RCreateMixIn
 from .rdelete import RDeleteMixIn
+from .rlist import RListMixIn
 from .serve import ServeMixIn
 from .tar import TarMixIn
 from .transfer import TransferMixIn
@@ -127,6 +127,7 @@ class Archiver(
     RenameMixIn,
     RCreateMixIn,
     RDeleteMixIn,
+    RListMixIn,
     ServeMixIn,
     TransferMixIn,
 ):
@@ -701,30 +702,6 @@ class Archiver(
             pi.finish()
         return self.exit_code
 
-    @with_repository(compatibility=(Manifest.Operation.READ,))
-    def do_rlist(self, args, repository, manifest, key):
-        """List the archives contained in a repository"""
-        if args.format is not None:
-            format = args.format
-        elif args.short:
-            format = "{archive}{NL}"
-        else:
-            format = "{archive:<36} {time} [{id}]{NL}"
-        formatter = ArchiveFormatter(format, repository, manifest, key, json=args.json, iec=args.iec)
-
-        output_data = []
-
-        for archive_info in manifest.archives.list_considering(args):
-            if args.json:
-                output_data.append(formatter.get_item_data(archive_info))
-            else:
-                sys.stdout.write(formatter.format_item(archive_info))
-
-        if args.json:
-            json_print(basic_json_data(manifest, extra={"archives": output_data}))
-
-        return self.exit_code
-
     @with_repository(cache=True, compatibility=(Manifest.Operation.READ,))
     def do_rinfo(self, args, repository, manifest, key, cache):
         """Show repository infos"""
@@ -1574,6 +1551,7 @@ class Archiver(
         self.build_parser_delete(subparsers, common_parser, mid_common_parser)
         self.build_parser_help(subparsers, common_parser, mid_common_parser, parser)
         self.build_parser_rdelete(subparsers, common_parser, mid_common_parser, parser)
+        self.build_parser_rlist(subparsers, common_parser, mid_common_parser)
 
         # borg extract
         extract_epilog = process_epilog(
@@ -1707,86 +1685,6 @@ class Archiver(
         self.build_parser_keys(subparsers, common_parser, mid_common_parser)
         self.build_parser_rcreate(subparsers, common_parser, mid_common_parser)
 
-        # borg rlist
-        rlist_epilog = (
-            process_epilog(
-                """
-        This command lists the archives contained in a repository.
-
-        .. man NOTES
-
-        The FORMAT specifier syntax
-        +++++++++++++++++++++++++++
-
-        The ``--format`` option uses python's `format string syntax
-        <https://docs.python.org/3.9/library/string.html#formatstrings>`_.
-
-        Examples:
-        ::
-
-            $ borg rlist --format '{archive}{NL}'
-            ArchiveFoo
-            ArchiveBar
-            ...
-
-            # {VAR:NUMBER} - pad to NUMBER columns.
-            # Strings are left-aligned, numbers are right-aligned.
-            # Note: time columns except ``isomtime``, ``isoctime`` and ``isoatime`` cannot be padded.
-            $ borg rlist --format '{archive:36} {time} [{id}]{NL}' /path/to/repo
-            ArchiveFoo                           Thu, 2021-12-09 10:22:28 [0b8e9a312bef3f2f6e2d0fc110c196827786c15eba0188738e81697a7fa3b274]
-            ...
-
-        The following keys are always available:
-
-
-        """
-            )
-            + BaseFormatter.keys_help()
-            + textwrap.dedent(
-                """
-
-        Keys available only when listing archives in a repository:
-
-        """
-            )
-            + ArchiveFormatter.keys_help()
-        )
-        subparser = subparsers.add_parser(
-            "rlist",
-            parents=[common_parser],
-            add_help=False,
-            description=self.do_rlist.__doc__,
-            epilog=rlist_epilog,
-            formatter_class=argparse.RawDescriptionHelpFormatter,
-            help="list repository contents",
-        )
-        subparser.set_defaults(func=self.do_rlist)
-        subparser.add_argument(
-            "--consider-checkpoints",
-            action="store_true",
-            dest="consider_checkpoints",
-            help="Show checkpoint archives in the repository contents list (default: hidden).",
-        )
-        subparser.add_argument(
-            "--short", dest="short", action="store_true", help="only print the archive names, nothing else"
-        )
-        subparser.add_argument(
-            "--format",
-            metavar="FORMAT",
-            dest="format",
-            help="specify format for archive listing " '(default: "{archive:<36} {time} [{id}]{NL}")',
-        )
-        subparser.add_argument(
-            "--json",
-            action="store_true",
-            help="Format output as JSON. "
-            "The form of ``--format`` is ignored, "
-            "but keys used in it are added to the JSON output. "
-            "Some keys are always present. Note: JSON can only represent text. "
-            'A "barchive" key is therefore not available.',
-        )
-        define_archive_filters_group(subparser)
-
         # borg recreate
         recreate_epilog = process_epilog(
             """
diff --git a/src/borg/archiver/rlist.py b/src/borg/archiver/rlist.py
new file mode 100644
index 000000000..02012320c
--- /dev/null
+++ b/src/borg/archiver/rlist.py
@@ -0,0 +1,120 @@
+import argparse
+import textwrap
+import sys
+
+from .common import with_repository
+from ..constants import *  # NOQA
+from ..helpers import Manifest
+from ..helpers import BaseFormatter, ArchiveFormatter, json_print, basic_json_data
+
+from ..logger import create_logger
+
+logger = create_logger()
+
+
+class RListMixIn:
+    @with_repository(compatibility=(Manifest.Operation.READ,))
+    def do_rlist(self, args, repository, manifest, key):
+        """List the archives contained in a repository"""
+        if args.format is not None:
+            format = args.format
+        elif args.short:
+            format = "{archive}{NL}"
+        else:
+            format = "{archive:<36} {time} [{id}]{NL}"
+        formatter = ArchiveFormatter(format, repository, manifest, key, json=args.json, iec=args.iec)
+
+        output_data = []
+
+        for archive_info in manifest.archives.list_considering(args):
+            if args.json:
+                output_data.append(formatter.get_item_data(archive_info))
+            else:
+                sys.stdout.write(formatter.format_item(archive_info))
+
+        if args.json:
+            json_print(basic_json_data(manifest, extra={"archives": output_data}))
+
+        return self.exit_code
+
+    def build_parser_rlist(self, subparsers, common_parser, mid_common_parser):
+        from .common import process_epilog, define_archive_filters_group
+
+        rlist_epilog = (
+            process_epilog(
+                """
+        This command lists the archives contained in a repository.
+
+        .. man NOTES
+
+        The FORMAT specifier syntax
+        +++++++++++++++++++++++++++
+
+        The ``--format`` option uses python's `format string syntax
+        <https://docs.python.org/3.9/library/string.html#formatstrings>`_.
+
+        Examples:
+        ::
+
+            $ borg rlist --format '{archive}{NL}'
+            ArchiveFoo
+            ArchiveBar
+            ...
+
+            # {VAR:NUMBER} - pad to NUMBER columns.
+            # Strings are left-aligned, numbers are right-aligned.
+            # Note: time columns except ``isomtime``, ``isoctime`` and ``isoatime`` cannot be padded.
+            $ borg rlist --format '{archive:36} {time} [{id}]{NL}' /path/to/repo
+            ArchiveFoo                           Thu, 2021-12-09 10:22:28 [0b8e9a312bef3f2f6e2d0fc110c196827786c15eba0188738e81697a7fa3b274]
+            ...
+
+        The following keys are always available:
+
+
+        """
+            )
+            + BaseFormatter.keys_help()
+            + textwrap.dedent(
+                """
+
+        Keys available only when listing archives in a repository:
+
+        """
+            )
+            + ArchiveFormatter.keys_help()
+        )
+        subparser = subparsers.add_parser(
+            "rlist",
+            parents=[common_parser],
+            add_help=False,
+            description=self.do_rlist.__doc__,
+            epilog=rlist_epilog,
+            formatter_class=argparse.RawDescriptionHelpFormatter,
+            help="list repository contents",
+        )
+        subparser.set_defaults(func=self.do_rlist)
+        subparser.add_argument(
+            "--consider-checkpoints",
+            action="store_true",
+            dest="consider_checkpoints",
+            help="Show checkpoint archives in the repository contents list (default: hidden).",
+        )
+        subparser.add_argument(
+            "--short", dest="short", action="store_true", help="only print the archive names, nothing else"
+        )
+        subparser.add_argument(
+            "--format",
+            metavar="FORMAT",
+            dest="format",
+            help="specify format for archive listing " '(default: "{archive:<36} {time} [{id}]{NL}")',
+        )
+        subparser.add_argument(
+            "--json",
+            action="store_true",
+            help="Format output as JSON. "
+            "The form of ``--format`` is ignored, "
+            "but keys used in it are added to the JSON output. "
+            "Some keys are always present. Note: JSON can only represent text. "
+            'A "barchive" key is therefore not available.',
+        )
+        define_archive_filters_group(subparser)

From 4d5a89ebc3ef7af8c18bdba4645320e8f6d4fe8b Mon Sep 17 00:00:00 2001
From: Thomas Waldmann <tw@waldmann-edv.de>
Date: Sat, 9 Jul 2022 01:41:36 +0200
Subject: [PATCH 139/160] move rinfo command to archiver.rinfo

---
 src/borg/archiver/__init__.py | 73 ++----------------------------
 src/borg/archiver/rinfo.py    | 83 +++++++++++++++++++++++++++++++++++
 2 files changed, 87 insertions(+), 69 deletions(-)
 create mode 100644 src/borg/archiver/rinfo.py

diff --git a/src/borg/archiver/__init__.py b/src/borg/archiver/__init__.py
index ef6ca28e1..c63083564 100644
--- a/src/borg/archiver/__init__.py
+++ b/src/borg/archiver/__init__.py
@@ -39,7 +39,7 @@ try:
     from ..helpers import location_validator, archivename_validator, ChunkerParams, Location
     from ..helpers import NameSpec, CommentSpec, FilesCacheMode
     from ..helpers import format_timedelta, format_file_size
-    from ..helpers import remove_surrogates, bin_to_hex, eval_escapes
+    from ..helpers import remove_surrogates, eval_escapes
     from ..helpers import timestamp
     from ..helpers import get_cache_dir, os_stat
     from ..helpers import Manifest
@@ -102,6 +102,7 @@ from .mount import MountMixIn
 from .prune import PruneMixIn
 from .rename import RenameMixIn
 from .rcreate import RCreateMixIn
+from .rinfo import RInfoMixIn
 from .rdelete import RDeleteMixIn
 from .rlist import RListMixIn
 from .serve import ServeMixIn
@@ -126,6 +127,7 @@ class Archiver(
     HelpMixIn,
     RenameMixIn,
     RCreateMixIn,
+    RInfoMixIn,
     RDeleteMixIn,
     RListMixIn,
     ServeMixIn,
@@ -702,47 +704,6 @@ class Archiver(
             pi.finish()
         return self.exit_code
 
-    @with_repository(cache=True, compatibility=(Manifest.Operation.READ,))
-    def do_rinfo(self, args, repository, manifest, key, cache):
-        """Show repository infos"""
-        info = basic_json_data(manifest, cache=cache, extra={"security_dir": cache.security_manager.dir})
-
-        if args.json:
-            json_print(info)
-        else:
-            encryption = "Encrypted: "
-            if key.NAME in ("plaintext", "authenticated"):
-                encryption += "No"
-            else:
-                encryption += "Yes (%s)" % key.NAME
-            if key.NAME.startswith("key file"):
-                encryption += "\nKey file: %s" % key.find_key()
-            info["encryption"] = encryption
-
-            print(
-                textwrap.dedent(
-                    """
-            Repository ID: {id}
-            Location: {location}
-            Repository version: {version}
-            Append only: {append_only}
-            {encryption}
-            Cache: {cache.path}
-            Security dir: {security_dir}
-            """
-                )
-                .strip()
-                .format(
-                    id=bin_to_hex(repository.id),
-                    location=repository._location.canonical_path(),
-                    version=repository.version,
-                    append_only=repository.append_only,
-                    **info,
-                )
-            )
-            print(str(cache))
-        return self.exit_code
-
     @with_repository(cache=True, compatibility=(Manifest.Operation.READ,))
     def do_info(self, args, repository, manifest, key, cache):
         """Show archive details such as disk space used"""
@@ -1551,6 +1512,7 @@ class Archiver(
         self.build_parser_delete(subparsers, common_parser, mid_common_parser)
         self.build_parser_help(subparsers, common_parser, mid_common_parser, parser)
         self.build_parser_rdelete(subparsers, common_parser, mid_common_parser, parser)
+        self.build_parser_rinfo(subparsers, common_parser, mid_common_parser)
         self.build_parser_rlist(subparsers, common_parser, mid_common_parser)
 
         # borg extract
@@ -1622,33 +1584,6 @@ class Archiver(
         )
         define_exclusion_group(subparser, strip_components=True)
 
-        # borg rinfo
-        rinfo_epilog = process_epilog(
-            """
-        This command displays detailed information about the repository.
-
-        Please note that the deduplicated sizes of the individual archives do not add
-        up to the deduplicated size of the repository ("all archives"), because the two
-        are meaning different things:
-
-        This archive / deduplicated size = amount of data stored ONLY for this archive
-        = unique chunks of this archive.
-        All archives / deduplicated size = amount of data stored in the repo
-        = all chunks in the repository.
-        """
-        )
-        subparser = subparsers.add_parser(
-            "rinfo",
-            parents=[common_parser],
-            add_help=False,
-            description=self.do_rinfo.__doc__,
-            epilog=rinfo_epilog,
-            formatter_class=argparse.RawDescriptionHelpFormatter,
-            help="show repository information",
-        )
-        subparser.set_defaults(func=self.do_rinfo)
-        subparser.add_argument("--json", action="store_true", help="format output as JSON")
-
         # borg info
         info_epilog = process_epilog(
             """
diff --git a/src/borg/archiver/rinfo.py b/src/borg/archiver/rinfo.py
new file mode 100644
index 000000000..19e810db0
--- /dev/null
+++ b/src/borg/archiver/rinfo.py
@@ -0,0 +1,83 @@
+import argparse
+import textwrap
+
+from .common import with_repository
+from ..constants import *  # NOQA
+from ..helpers import Manifest
+from ..helpers import bin_to_hex, json_print, basic_json_data
+
+from ..logger import create_logger
+
+logger = create_logger()
+
+
+class RInfoMixIn:
+    @with_repository(cache=True, compatibility=(Manifest.Operation.READ,))
+    def do_rinfo(self, args, repository, manifest, key, cache):
+        """Show repository infos"""
+        info = basic_json_data(manifest, cache=cache, extra={"security_dir": cache.security_manager.dir})
+
+        if args.json:
+            json_print(info)
+        else:
+            encryption = "Encrypted: "
+            if key.NAME in ("plaintext", "authenticated"):
+                encryption += "No"
+            else:
+                encryption += "Yes (%s)" % key.NAME
+            if key.NAME.startswith("key file"):
+                encryption += "\nKey file: %s" % key.find_key()
+            info["encryption"] = encryption
+
+            print(
+                textwrap.dedent(
+                    """
+            Repository ID: {id}
+            Location: {location}
+            Repository version: {version}
+            Append only: {append_only}
+            {encryption}
+            Cache: {cache.path}
+            Security dir: {security_dir}
+            """
+                )
+                .strip()
+                .format(
+                    id=bin_to_hex(repository.id),
+                    location=repository._location.canonical_path(),
+                    version=repository.version,
+                    append_only=repository.append_only,
+                    **info,
+                )
+            )
+            print(str(cache))
+        return self.exit_code
+
+    def build_parser_rinfo(self, subparsers, common_parser, mid_common_parser):
+        from .common import process_epilog
+
+        rinfo_epilog = process_epilog(
+            """
+        This command displays detailed information about the repository.
+
+        Please note that the deduplicated sizes of the individual archives do not add
+        up to the deduplicated size of the repository ("all archives"), because the two
+        are meaning different things:
+
+        This archive / deduplicated size = amount of data stored ONLY for this archive
+        = unique chunks of this archive.
+        All archives / deduplicated size = amount of data stored in the repo
+        = all chunks in the repository.
+        """
+        )
+        subparser = subparsers.add_parser(
+            "rinfo",
+            parents=[common_parser],
+            add_help=False,
+            description=self.do_rinfo.__doc__,
+            epilog=rinfo_epilog,
+            formatter_class=argparse.RawDescriptionHelpFormatter,
+            help="show repository information",
+        )
+        subparser.set_defaults(func=self.do_rinfo)
+        subparser.add_argument("--json", action="store_true", help="format output as JSON")

From e57f3bb424f5a416bb132668db51743da58bb9a9 Mon Sep 17 00:00:00 2001
From: Thomas Waldmann <tw@waldmann-edv.de>
Date: Sat, 9 Jul 2022 01:52:32 +0200
Subject: [PATCH 140/160] move info command to archiver.info

---
 src/borg/archiver/__init__.py |  99 ++----------------------------
 src/borg/archiver/info.py     | 109 ++++++++++++++++++++++++++++++++++
 2 files changed, 114 insertions(+), 94 deletions(-)
 create mode 100644 src/borg/archiver/info.py

diff --git a/src/borg/archiver/__init__.py b/src/borg/archiver/__init__.py
index c63083564..8c65e6f67 100644
--- a/src/borg/archiver/__init__.py
+++ b/src/borg/archiver/__init__.py
@@ -16,9 +16,8 @@ try:
     import signal
     import stat
     import subprocess
-    import textwrap
     import time
-    from datetime import datetime, timedelta
+    from datetime import datetime
     from io import TextIOWrapper
 
     from ..logger import create_logger, setup_logging
@@ -38,7 +37,7 @@ try:
     from ..helpers import Error, set_ec
     from ..helpers import location_validator, archivename_validator, ChunkerParams, Location
     from ..helpers import NameSpec, CommentSpec, FilesCacheMode
-    from ..helpers import format_timedelta, format_file_size
+    from ..helpers import format_file_size
     from ..helpers import remove_surrogates, eval_escapes
     from ..helpers import timestamp
     from ..helpers import get_cache_dir, os_stat
@@ -95,6 +94,7 @@ from .debug import DebugMixIn
 from .delete import DeleteMixIn
 from .diff import DiffMixIn
 from .help import HelpMixIn
+from .info import InfoMixIn
 from .keys import KeysMixIn
 from .list_cmd import ListMixIn
 from .locks import LocksMixIn
@@ -125,6 +125,7 @@ class Archiver(
     MountMixIn,
     PruneMixIn,
     HelpMixIn,
+    InfoMixIn,
     RenameMixIn,
     RCreateMixIn,
     RInfoMixIn,
@@ -704,64 +705,6 @@ class Archiver(
             pi.finish()
         return self.exit_code
 
-    @with_repository(cache=True, compatibility=(Manifest.Operation.READ,))
-    def do_info(self, args, repository, manifest, key, cache):
-        """Show archive details such as disk space used"""
-
-        def format_cmdline(cmdline):
-            return remove_surrogates(" ".join(shlex.quote(x) for x in cmdline))
-
-        args.consider_checkpoints = True
-        archive_names = tuple(x.name for x in manifest.archives.list_considering(args))
-
-        output_data = []
-
-        for i, archive_name in enumerate(archive_names, 1):
-            archive = Archive(
-                repository,
-                key,
-                manifest,
-                archive_name,
-                cache=cache,
-                consider_part_files=args.consider_part_files,
-                iec=args.iec,
-            )
-            info = archive.info()
-            if args.json:
-                output_data.append(info)
-            else:
-                info["duration"] = format_timedelta(timedelta(seconds=info["duration"]))
-                info["command_line"] = format_cmdline(info["command_line"])
-                print(
-                    textwrap.dedent(
-                        """
-                Archive name: {name}
-                Archive fingerprint: {id}
-                Comment: {comment}
-                Hostname: {hostname}
-                Username: {username}
-                Time (start): {start}
-                Time (end): {end}
-                Duration: {duration}
-                Command line: {command_line}
-                Utilization of maximum supported archive size: {limits[max_archive_size]:.0%}
-                Number of files: {stats[nfiles]}
-                Original size: {stats[original_size]}
-                Deduplicated size: {stats[deduplicated_size]}
-                """
-                    )
-                    .strip()
-                    .format(**info)
-                )
-            if self.exit_code:
-                break
-            if not args.json and len(archive_names) - i:
-                print()
-
-        if args.json:
-            json_print(basic_json_data(manifest, cache=cache, extra={"archives": output_data}))
-        return self.exit_code
-
     @with_repository(cache=True, exclusive=True, compatibility=(Manifest.Operation.CHECK,))
     def do_recreate(self, args, repository, manifest, key, cache):
         """Re-create archives"""
@@ -1584,39 +1527,7 @@ class Archiver(
         )
         define_exclusion_group(subparser, strip_components=True)
 
-        # borg info
-        info_epilog = process_epilog(
-            """
-        This command displays detailed information about the specified archive.
-
-        Please note that the deduplicated sizes of the individual archives do not add
-        up to the deduplicated size of the repository ("all archives"), because the two
-        are meaning different things:
-
-        This archive / deduplicated size = amount of data stored ONLY for this archive
-        = unique chunks of this archive.
-        All archives / deduplicated size = amount of data stored in the repo
-        = all chunks in the repository.
-
-        Borg archives can only contain a limited amount of file metadata.
-        The size of an archive relative to this limit depends on a number of factors,
-        mainly the number of files, the lengths of paths and other metadata stored for files.
-        This is shown as *utilization of maximum supported archive size*.
-        """
-        )
-        subparser = subparsers.add_parser(
-            "info",
-            parents=[common_parser],
-            add_help=False,
-            description=self.do_info.__doc__,
-            epilog=info_epilog,
-            formatter_class=argparse.RawDescriptionHelpFormatter,
-            help="show repository or archive information",
-        )
-        subparser.set_defaults(func=self.do_info)
-        subparser.add_argument("--json", action="store_true", help="format output as JSON")
-        define_archive_filters_group(subparser)
-
+        self.build_parser_info(subparsers, common_parser, mid_common_parser)
         self.build_parser_keys(subparsers, common_parser, mid_common_parser)
         self.build_parser_rcreate(subparsers, common_parser, mid_common_parser)
 
diff --git a/src/borg/archiver/info.py b/src/borg/archiver/info.py
new file mode 100644
index 000000000..011c7748a
--- /dev/null
+++ b/src/borg/archiver/info.py
@@ -0,0 +1,109 @@
+import argparse
+import shlex
+import textwrap
+from datetime import timedelta
+
+from .common import with_repository
+from ..archive import Archive
+from ..constants import *  # NOQA
+from ..helpers import Manifest
+from ..helpers import remove_surrogates, format_timedelta, json_print, basic_json_data
+
+from ..logger import create_logger
+
+logger = create_logger()
+
+
+class InfoMixIn:
+    @with_repository(cache=True, compatibility=(Manifest.Operation.READ,))
+    def do_info(self, args, repository, manifest, key, cache):
+        """Show archive details such as disk space used"""
+
+        def format_cmdline(cmdline):
+            return remove_surrogates(" ".join(shlex.quote(x) for x in cmdline))
+
+        args.consider_checkpoints = True
+        archive_names = tuple(x.name for x in manifest.archives.list_considering(args))
+
+        output_data = []
+
+        for i, archive_name in enumerate(archive_names, 1):
+            archive = Archive(
+                repository,
+                key,
+                manifest,
+                archive_name,
+                cache=cache,
+                consider_part_files=args.consider_part_files,
+                iec=args.iec,
+            )
+            info = archive.info()
+            if args.json:
+                output_data.append(info)
+            else:
+                info["duration"] = format_timedelta(timedelta(seconds=info["duration"]))
+                info["command_line"] = format_cmdline(info["command_line"])
+                print(
+                    textwrap.dedent(
+                        """
+                Archive name: {name}
+                Archive fingerprint: {id}
+                Comment: {comment}
+                Hostname: {hostname}
+                Username: {username}
+                Time (start): {start}
+                Time (end): {end}
+                Duration: {duration}
+                Command line: {command_line}
+                Utilization of maximum supported archive size: {limits[max_archive_size]:.0%}
+                Number of files: {stats[nfiles]}
+                Original size: {stats[original_size]}
+                Deduplicated size: {stats[deduplicated_size]}
+                """
+                    )
+                    .strip()
+                    .format(**info)
+                )
+            if self.exit_code:
+                break
+            if not args.json and len(archive_names) - i:
+                print()
+
+        if args.json:
+            json_print(basic_json_data(manifest, cache=cache, extra={"archives": output_data}))
+        return self.exit_code
+
+    def build_parser_info(self, subparsers, common_parser, mid_common_parser):
+        from .common import process_epilog, define_archive_filters_group
+
+        info_epilog = process_epilog(
+            """
+        This command displays detailed information about the specified archive.
+
+        Please note that the deduplicated sizes of the individual archives do not add
+        up to the deduplicated size of the repository ("all archives"), because the two
+        are meaning different things:
+
+        This archive / deduplicated size = amount of data stored ONLY for this archive
+        = unique chunks of this archive.
+        All archives / deduplicated size = amount of data stored in the repo
+        = all chunks in the repository.
+
+        Borg archives can only contain a limited amount of file metadata.
+        The size of an archive relative to this limit depends on a number of factors,
+        mainly the number of files, the lengths of paths and other metadata stored for files.
+        This is shown as *utilization of maximum supported archive size*.
+        """
+        )
+        subparser = subparsers.add_parser(
+            "info",
+            parents=[common_parser],
+            add_help=False,
+            description=self.do_info.__doc__,
+            epilog=info_epilog,
+            formatter_class=argparse.RawDescriptionHelpFormatter,
+            help="show repository or archive information",
+        )
+        subparser.set_defaults(func=self.do_info)
+        subparser.add_argument("--json", action="store_true", help="format output as JSON")
+        define_archive_filters_group(subparser)

From e05f7971dadc4d466cc17d1bc902fdb5ba01095e Mon Sep 17 00:00:00 2001
From: Thomas Waldmann <tw@waldmann-edv.de>
Date: Sat, 9 Jul 2022 02:15:37 +0200
Subject: [PATCH 141/160] move build_filter/build_matcher to archiver.common

---
 src/borg/archiver/__init__.py  | 30 ++++--------------------------
 src/borg/archiver/common.py    | 25 +++++++++++++++++++++++++
 src/borg/archiver/diff.py      |  4 ++--
 src/borg/archiver/list_cmd.py  |  4 ++--
 src/borg/archiver/tar.py       |  5 +++--
 src/borg/fuse.py               |  6 +++---
 src/borg/testsuite/archiver.py |  7 ++++---
 7 files changed, 43 insertions(+), 38 deletions(-)

diff --git a/src/borg/archiver/__init__.py b/src/borg/archiver/__init__.py
index 8c65e6f67..cc4e00c76 100644
--- a/src/borg/archiver/__init__.py
+++ b/src/borg/archiver/__init__.py
@@ -25,6 +25,7 @@ try:
     logger = create_logger()
 
     from .common import with_repository, with_archive, Highlander
+    from .common import build_filter, build_matcher
     from .. import __version__
     from .. import helpers
     from ..archive import Archive, ArchiveRecreater, is_special
@@ -160,13 +161,6 @@ class Archiver(
             else:
                 logging.getLogger("borg.output.list").info("%1s %s", status, remove_surrogates(path))
 
-    @staticmethod
-    def build_matcher(inclexcl_patterns, include_paths):
-        matcher = PatternMatcher()
-        matcher.add_inclexcl(inclexcl_patterns)
-        matcher.add_includepaths(include_paths)
-        return matcher
-
     @with_repository(fake="dry_run", exclusive=True, compatibility=(Manifest.Operation.WRITE,))
     def do_create(self, args, repository, manifest=None, key=None):
         """Create new archive"""
@@ -601,22 +595,6 @@ class Archiver(
         if not recurse_excluded_dir:
             self.print_file_status(status, path)
 
-    @staticmethod
-    def build_filter(matcher, strip_components):
-        if strip_components:
-
-            def item_filter(item):
-                matched = matcher.match(item.path) and os.sep.join(item.path.split(os.sep)[strip_components:])
-                return matched
-
-        else:
-
-            def item_filter(item):
-                matched = matcher.match(item.path)
-                return matched
-
-        return item_filter
-
     @with_repository(compatibility=(Manifest.Operation.READ,))
     @with_archive
     def do_extract(self, args, repository, manifest, key, archive):
@@ -631,7 +609,7 @@ class Archiver(
                     "Hint: You likely need to fix your locale setup. E.g. install locales and use: LANG=en_US.UTF-8"
                 )
 
-        matcher = self.build_matcher(args.patterns, args.paths)
+        matcher = build_matcher(args.patterns, args.paths)
 
         progress = args.progress
         output_list = args.output_list
@@ -642,7 +620,7 @@ class Archiver(
         dirs = []
         hlm = HardLinkManager(id_type=bytes, info_type=str)  # hlid -> path
 
-        filter = self.build_filter(matcher, strip_components)
+        filter = build_filter(matcher, strip_components)
         if progress:
             pi = ProgressIndicatorPercent(msg="%5.1f%% Extracting: %s", step=0.1, msgid="extract")
             pi.output("Calculating total archive size for the progress indicator (might take long for large archives)")
@@ -708,7 +686,7 @@ class Archiver(
     @with_repository(cache=True, exclusive=True, compatibility=(Manifest.Operation.CHECK,))
     def do_recreate(self, args, repository, manifest, key, cache):
         """Re-create archives"""
-        matcher = self.build_matcher(args.patterns, args.paths)
+        matcher = build_matcher(args.patterns, args.paths)
         self.output_list = args.output_list
         self.output_filter = args.output_filter
         recompress = args.recompress != "never"
diff --git a/src/borg/archiver/common.py b/src/borg/archiver/common.py
index 3be4c1466..285832295 100644
--- a/src/borg/archiver/common.py
+++ b/src/borg/archiver/common.py
@@ -1,5 +1,6 @@
 import argparse
 import functools
+import os
 import textwrap
 
 import borg
@@ -9,6 +10,7 @@ from ..cache import Cache, assert_secure
 from ..helpers import Error
 from ..helpers import Manifest, AI_HUMAN_SORT_KEYS
 from ..helpers import GlobSpec, SortBySpec, positive_int_validator
+from ..patterns import PatternMatcher
 from ..remote import RemoteRepository
 from ..repository import Repository
 from ..nanorst import rst_to_terminal
@@ -420,3 +422,26 @@ def define_archive_filters_group(subparser, *, sort_by=True, first_last=True):
         )
 
     return filters_group
+
+
+def build_matcher(inclexcl_patterns, include_paths):
+    matcher = PatternMatcher()
+    matcher.add_inclexcl(inclexcl_patterns)
+    matcher.add_includepaths(include_paths)
+    return matcher
+
+
+def build_filter(matcher, strip_components):
+    if strip_components:
+
+        def item_filter(item):
+            matched = matcher.match(item.path) and os.sep.join(item.path.split(os.sep)[strip_components:])
+            return matched
+
+    else:
+
+        def item_filter(item):
+            matched = matcher.match(item.path)
+            return matched
+
+    return item_filter
diff --git a/src/borg/archiver/diff.py b/src/borg/archiver/diff.py
index d06ebe0f5..d1b1a4e07 100644
--- a/src/borg/archiver/diff.py
+++ b/src/borg/archiver/diff.py
@@ -1,7 +1,7 @@
 import argparse
 import json
 
-from .common import with_repository, with_archive
+from .common import with_repository, with_archive, build_matcher
 from ..archive import Archive
 from ..constants import *  # NOQA
 from ..helpers import archivename_validator
@@ -40,7 +40,7 @@ class DiffMixIn:
                 "to override this check."
             )
 
-        matcher = self.build_matcher(args.patterns, args.paths)
+        matcher = build_matcher(args.patterns, args.paths)
 
         diffs = Archive.compare_archives_iter(archive1, archive2, matcher, can_compare_chunk_ids=can_compare_chunk_ids)
         # Conversion to string and filtering for diff.equal to save memory if sorting
diff --git a/src/borg/archiver/list_cmd.py b/src/borg/archiver/list_cmd.py
index a48ee2a09..e21bab33c 100644
--- a/src/borg/archiver/list_cmd.py
+++ b/src/borg/archiver/list_cmd.py
@@ -2,7 +2,7 @@ import argparse
 import textwrap
 import sys
 
-from .common import with_repository
+from .common import with_repository, build_matcher
 from ..archive import Archive
 from ..cache import Cache
 from ..constants import *  # NOQA
@@ -18,7 +18,7 @@ class ListMixIn:
     @with_repository(compatibility=(Manifest.Operation.READ,))
     def do_list(self, args, repository, manifest, key):
         """List archive contents"""
-        matcher = self.build_matcher(args.patterns, args.paths)
+        matcher = build_matcher(args.patterns, args.paths)
         if args.format is not None:
             format = args.format
         elif args.short:
diff --git a/src/borg/archiver/tar.py b/src/borg/archiver/tar.py
index eb71cb2d8..be35f58b6 100644
--- a/src/borg/archiver/tar.py
+++ b/src/borg/archiver/tar.py
@@ -26,6 +26,7 @@ from ..helpers import basic_json_data, json_print
 from ..helpers import log_multi
 
 from .common import with_repository, with_archive, Highlander, define_exclusion_group
+from .common import build_matcher, build_filter
 
 from ..logger import create_logger
 
@@ -68,14 +69,14 @@ class TarMixIn:
         return self.exit_code
 
     def _export_tar(self, args, archive, tarstream):
-        matcher = self.build_matcher(args.patterns, args.paths)
+        matcher = build_matcher(args.patterns, args.paths)
 
         progress = args.progress
         output_list = args.output_list
         strip_components = args.strip_components
         hlm = HardLinkManager(id_type=bytes, info_type=str)  # hlid -> path
 
-        filter = self.build_filter(matcher, strip_components)
+        filter = build_filter(matcher, strip_components)
 
         # The | (pipe) symbol instructs tarfile to use a streaming mode of operation
         # where it never seeks on the passed fileobj.
diff --git a/src/borg/fuse.py b/src/borg/fuse.py
index 9caafd73b..2b7a222db 100644
--- a/src/borg/fuse.py
+++ b/src/borg/fuse.py
@@ -35,7 +35,7 @@ from .logger import create_logger
 logger = create_logger()
 
 from .crypto.low_level import blake2b_128
-from .archiver import Archiver
+from .archiver.common import build_matcher, build_filter
 from .archive import Archive, get_item_uid_gid
 from .hashindex import FuseVersionsIndex
 from .helpers import daemonize, daemonizing, signal_handler, format_file_size
@@ -338,10 +338,10 @@ class FuseBackend:
             consider_part_files=self._args.consider_part_files,
         )
         strip_components = self._args.strip_components
-        matcher = Archiver.build_matcher(self._args.patterns, self._args.paths)
+        matcher = build_matcher(self._args.patterns, self._args.paths)
         hlm = HardLinkManager(id_type=bytes, info_type=str)  # hlid -> path
 
-        filter = Archiver.build_filter(matcher, strip_components)
+        filter = build_filter(matcher, strip_components)
         for item_inode, item in self.cache.iter_archive_items(
             archive.metadata.items, filter=filter, consider_part_files=self._args.consider_part_files
         ):
diff --git a/src/borg/testsuite/archiver.py b/src/borg/testsuite/archiver.py
index 0561dabe7..d4437b230 100644
--- a/src/borg/testsuite/archiver.py
+++ b/src/borg/testsuite/archiver.py
@@ -32,6 +32,7 @@ import borg.helpers.errors
 from .. import xattr, helpers, platform
 from ..archive import Archive, ChunkBuffer
 from ..archiver import Archiver, PURE_PYTHON_MSGPACK_WARNING
+from ..archiver.common import build_filter, build_matcher
 from ..cache import Cache, LocalCache
 from ..chunker import has_seek_hole
 from ..constants import *  # NOQA
@@ -4573,19 +4574,19 @@ class TestBuildFilter:
     def test_basic(self):
         matcher = PatternMatcher()
         matcher.add([parse_pattern("included")], IECommand.Include)
-        filter = Archiver.build_filter(matcher, 0)
+        filter = build_filter(matcher, 0)
         assert filter(Item(path="included"))
         assert filter(Item(path="included/file"))
         assert not filter(Item(path="something else"))
 
     def test_empty(self):
         matcher = PatternMatcher(fallback=True)
-        filter = Archiver.build_filter(matcher, 0)
+        filter = build_filter(matcher, 0)
         assert filter(Item(path="anything"))
 
     def test_strip_components(self):
         matcher = PatternMatcher(fallback=True)
-        filter = Archiver.build_filter(matcher, strip_components=1)
+        filter = build_filter(matcher, strip_components=1)
         assert not filter(Item(path="shallow"))
         assert not filter(Item(path="shallow/"))  # can this even happen? paths are normalized...
         assert filter(Item(path="deep enough/file"))

From ae6ef774954ccf3b9a4454d0ded4ace59899c749 Mon Sep 17 00:00:00 2001
From: Thomas Waldmann <tw@waldmann-edv.de>
Date: Sat, 9 Jul 2022 02:29:05 +0200
Subject: [PATCH 142/160] move extract command to archiver.extract

---
 src/borg/archiver/__init__.py | 167 +------------------------------
 src/borg/archiver/extract.py  | 182 ++++++++++++++++++++++++++++++++++
 2 files changed, 187 insertions(+), 162 deletions(-)
 create mode 100644 src/borg/archiver/extract.py

diff --git a/src/borg/archiver/__init__.py b/src/borg/archiver/__init__.py
index cc4e00c76..ac20c2dae 100644
--- a/src/borg/archiver/__init__.py
+++ b/src/borg/archiver/__init__.py
@@ -24,8 +24,8 @@ try:
 
     logger = create_logger()
 
-    from .common import with_repository, with_archive, Highlander
-    from .common import build_filter, build_matcher
+    from .common import with_repository, Highlander
+    from .common import build_matcher
     from .. import __version__
     from .. import helpers
     from ..archive import Archive, ArchiveRecreater, is_special
@@ -43,13 +43,11 @@ try:
     from ..helpers import timestamp
     from ..helpers import get_cache_dir, os_stat
     from ..helpers import Manifest
-    from ..helpers import HardLinkManager
     from ..helpers import check_python, check_extension_modules
     from ..helpers import dir_is_tagged, is_slow_msgpack, is_supported_msgpack, sysinfo
     from ..helpers import log_multi
     from ..helpers import signal_handler, raising_signal_handler, SigHup, SigTerm
     from ..helpers import ErrorIgnoringTextIOWrapper
-    from ..helpers import ProgressIndicatorPercent
     from ..helpers import basic_json_data, json_print
     from ..helpers import flags_root, flags_dir, flags_special_follow, flags_special
     from ..helpers import msgpack
@@ -94,6 +92,7 @@ from .config import ConfigMixIn
 from .debug import DebugMixIn
 from .delete import DeleteMixIn
 from .diff import DiffMixIn
+from .extract import ExtractMixIn
 from .help import HelpMixIn
 from .info import InfoMixIn
 from .keys import KeysMixIn
@@ -118,6 +117,7 @@ class Archiver(
     DebugMixIn,
     DeleteMixIn,
     DiffMixIn,
+    ExtractMixIn,
     TarMixIn,
     BenchmarkMixIn,
     KeysMixIn,
@@ -595,94 +595,6 @@ class Archiver(
         if not recurse_excluded_dir:
             self.print_file_status(status, path)
 
-    @with_repository(compatibility=(Manifest.Operation.READ,))
-    @with_archive
-    def do_extract(self, args, repository, manifest, key, archive):
-        """Extract archive contents"""
-        # be restrictive when restoring files, restore permissions later
-        if sys.getfilesystemencoding() == "ascii":
-            logger.warning(
-                'Warning: File system encoding is "ascii", extracting non-ascii filenames will not be supported.'
-            )
-            if sys.platform.startswith(("linux", "freebsd", "netbsd", "openbsd", "darwin")):
-                logger.warning(
-                    "Hint: You likely need to fix your locale setup. E.g. install locales and use: LANG=en_US.UTF-8"
-                )
-
-        matcher = build_matcher(args.patterns, args.paths)
-
-        progress = args.progress
-        output_list = args.output_list
-        dry_run = args.dry_run
-        stdout = args.stdout
-        sparse = args.sparse
-        strip_components = args.strip_components
-        dirs = []
-        hlm = HardLinkManager(id_type=bytes, info_type=str)  # hlid -> path
-
-        filter = build_filter(matcher, strip_components)
-        if progress:
-            pi = ProgressIndicatorPercent(msg="%5.1f%% Extracting: %s", step=0.1, msgid="extract")
-            pi.output("Calculating total archive size for the progress indicator (might take long for large archives)")
-            extracted_size = sum(item.get_size() for item in archive.iter_items(filter))
-            pi.total = extracted_size
-        else:
-            pi = None
-
-        for item in archive.iter_items(filter, preload=True):
-            orig_path = item.path
-            if strip_components:
-                item.path = os.sep.join(orig_path.split(os.sep)[strip_components:])
-            if not args.dry_run:
-                while dirs and not item.path.startswith(dirs[-1].path):
-                    dir_item = dirs.pop(-1)
-                    try:
-                        archive.extract_item(dir_item, stdout=stdout)
-                    except BackupOSError as e:
-                        self.print_warning("%s: %s", remove_surrogates(dir_item.path), e)
-            if output_list:
-                logging.getLogger("borg.output.list").info(remove_surrogates(item.path))
-            try:
-                if dry_run:
-                    archive.extract_item(item, dry_run=True, hlm=hlm, pi=pi)
-                else:
-                    if stat.S_ISDIR(item.mode):
-                        dirs.append(item)
-                        archive.extract_item(item, stdout=stdout, restore_attrs=False)
-                    else:
-                        archive.extract_item(
-                            item,
-                            stdout=stdout,
-                            sparse=sparse,
-                            hlm=hlm,
-                            stripped_components=strip_components,
-                            original_path=orig_path,
-                            pi=pi,
-                        )
-            except (BackupOSError, BackupError) as e:
-                self.print_warning("%s: %s", remove_surrogates(orig_path), e)
-
-        if pi:
-            pi.finish()
-
-        if not args.dry_run:
-            pi = ProgressIndicatorPercent(
-                total=len(dirs), msg="Setting directory permissions %3.0f%%", msgid="extract.permissions"
-            )
-            while dirs:
-                pi.show()
-                dir_item = dirs.pop(-1)
-                try:
-                    archive.extract_item(dir_item, stdout=stdout)
-                except BackupOSError as e:
-                    self.print_warning("%s: %s", remove_surrogates(dir_item.path), e)
-        for pattern in matcher.get_unmatched_include_patterns():
-            self.print_warning("Include pattern '%s' never matched.", pattern)
-        if pi:
-            # clear progress output
-            pi.finish()
-        return self.exit_code
-
     @with_repository(cache=True, exclusive=True, compatibility=(Manifest.Operation.CHECK,))
     def do_recreate(self, args, repository, manifest, key, cache):
         """Re-create archives"""
@@ -1431,80 +1343,11 @@ class Archiver(
         self.build_parser_config(subparsers, common_parser, mid_common_parser)
         self.build_parser_debug(subparsers, common_parser, mid_common_parser)
         self.build_parser_delete(subparsers, common_parser, mid_common_parser)
+        self.build_parser_extract(subparsers, common_parser, mid_common_parser)
         self.build_parser_help(subparsers, common_parser, mid_common_parser, parser)
         self.build_parser_rdelete(subparsers, common_parser, mid_common_parser, parser)
         self.build_parser_rinfo(subparsers, common_parser, mid_common_parser)
         self.build_parser_rlist(subparsers, common_parser, mid_common_parser)
-
-        # borg extract
-        extract_epilog = process_epilog(
-            """
-        This command extracts the contents of an archive. By default the entire
-        archive is extracted but a subset of files and directories can be selected
-        by passing a list of ``PATHs`` as arguments. The file selection can further
-        be restricted by using the ``--exclude`` option.
-
-        For more help on include/exclude patterns, see the :ref:`borg_patterns` command output.
-
-        By using ``--dry-run``, you can do all extraction steps except actually writing the
-        output data: reading metadata and data chunks from the repo, checking the hash/hmac,
-        decrypting, decompressing.
-
-        ``--progress`` can be slower than no progress display, since it makes one additional
-        pass over the archive metadata.
-
-        .. note::
-
-            Currently, extract always writes into the current working directory ("."),
-            so make sure you ``cd`` to the right place before calling ``borg extract``.
-
-            When parent directories are not extracted (because of using file/directory selection
-            or any other reason), borg can not restore parent directories' metadata, e.g. owner,
-            group, permission, etc.
-        """
-        )
-        subparser = subparsers.add_parser(
-            "extract",
-            parents=[common_parser],
-            add_help=False,
-            description=self.do_extract.__doc__,
-            epilog=extract_epilog,
-            formatter_class=argparse.RawDescriptionHelpFormatter,
-            help="extract archive contents",
-        )
-        subparser.set_defaults(func=self.do_extract)
-        subparser.add_argument(
-            "--list", dest="output_list", action="store_true", help="output verbose list of items (files, dirs, ...)"
-        )
-        subparser.add_argument(
-            "-n", "--dry-run", dest="dry_run", action="store_true", help="do not actually change any files"
-        )
-        subparser.add_argument(
-            "--numeric-ids",
-            dest="numeric_ids",
-            action="store_true",
-            help="only obey numeric user and group identifiers",
-        )
-        subparser.add_argument(
-            "--noflags", dest="noflags", action="store_true", help="do not extract/set flags (e.g. NODUMP, IMMUTABLE)"
-        )
-        subparser.add_argument("--noacls", dest="noacls", action="store_true", help="do not extract/set ACLs")
-        subparser.add_argument("--noxattrs", dest="noxattrs", action="store_true", help="do not extract/set xattrs")
-        subparser.add_argument(
-            "--stdout", dest="stdout", action="store_true", help="write all extracted data to stdout"
-        )
-        subparser.add_argument(
-            "--sparse",
-            dest="sparse",
-            action="store_true",
-            help="create holes in output sparse file from all-zero chunks",
-        )
-        subparser.add_argument("name", metavar="NAME", type=NameSpec, help="specify the archive name")
-        subparser.add_argument(
-            "paths", metavar="PATH", nargs="*", type=str, help="paths to extract; patterns are supported"
-        )
-        define_exclusion_group(subparser, strip_components=True)
-
         self.build_parser_info(subparsers, common_parser, mid_common_parser)
         self.build_parser_keys(subparsers, common_parser, mid_common_parser)
         self.build_parser_rcreate(subparsers, common_parser, mid_common_parser)
diff --git a/src/borg/archiver/extract.py b/src/borg/archiver/extract.py
new file mode 100644
index 000000000..5cd2f87d4
--- /dev/null
+++ b/src/borg/archiver/extract.py
@@ -0,0 +1,182 @@
+import sys
+import argparse
+import logging
+import os
+import stat
+
+from .common import with_repository, with_archive
+from .common import build_filter, build_matcher
+from ..archive import BackupError, BackupOSError
+from ..constants import *  # NOQA
+from ..helpers import NameSpec
+from ..helpers import remove_surrogates
+from ..helpers import Manifest
+from ..helpers import HardLinkManager
+from ..helpers import ProgressIndicatorPercent
+
+from ..logger import create_logger
+
+logger = create_logger()
+
+
+class ExtractMixIn:
+    @with_repository(compatibility=(Manifest.Operation.READ,))
+    @with_archive
+    def do_extract(self, args, repository, manifest, key, archive):
+        """Extract archive contents"""
+        # be restrictive when restoring files, restore permissions later
+        if sys.getfilesystemencoding() == "ascii":
+            logger.warning(
+                'Warning: File system encoding is "ascii", extracting non-ascii filenames will not be supported.'
+            )
+            if sys.platform.startswith(("linux", "freebsd", "netbsd", "openbsd", "darwin")):
+                logger.warning(
+                    "Hint: You likely need to fix your locale setup. E.g. install locales and use: LANG=en_US.UTF-8"
+                )
+
+        matcher = build_matcher(args.patterns, args.paths)
+
+        progress = args.progress
+        output_list = args.output_list
+        dry_run = args.dry_run
+        stdout = args.stdout
+        sparse = args.sparse
+        strip_components = args.strip_components
+        dirs = []
+        hlm = HardLinkManager(id_type=bytes, info_type=str)  # hlid -> path
+
+        filter = build_filter(matcher, strip_components)
+        if progress:
+            pi = ProgressIndicatorPercent(msg="%5.1f%% Extracting: %s", step=0.1, msgid="extract")
+            pi.output("Calculating total archive size for the progress indicator (might take long for large archives)")
+            extracted_size = sum(item.get_size() for item in archive.iter_items(filter))
+            pi.total = extracted_size
+        else:
+            pi = None
+
+        for item in archive.iter_items(filter, preload=True):
+            orig_path = item.path
+            if strip_components:
+                item.path = os.sep.join(orig_path.split(os.sep)[strip_components:])
+            if not args.dry_run:
+                while dirs and not item.path.startswith(dirs[-1].path):
+                    dir_item = dirs.pop(-1)
+                    try:
+                        archive.extract_item(dir_item, stdout=stdout)
+                    except BackupOSError as e:
+                        self.print_warning("%s: %s", remove_surrogates(dir_item.path), e)
+            if output_list:
+                logging.getLogger("borg.output.list").info(remove_surrogates(item.path))
+            try:
+                if dry_run:
+                    archive.extract_item(item, dry_run=True, hlm=hlm, pi=pi)
+                else:
+                    if stat.S_ISDIR(item.mode):
+                        dirs.append(item)
+                        archive.extract_item(item, stdout=stdout, restore_attrs=False)
+                    else:
+                        archive.extract_item(
+                            item,
+                            stdout=stdout,
+                            sparse=sparse,
+                            hlm=hlm,
+                            stripped_components=strip_components,
+                            original_path=orig_path,
+                            pi=pi,
+                        )
+            except (BackupOSError, BackupError) as e:
+                self.print_warning("%s: %s", remove_surrogates(orig_path), e)
+
+        if pi:
+            pi.finish()
+
+        if not args.dry_run:
+            pi = ProgressIndicatorPercent(
+                total=len(dirs), msg="Setting directory permissions %3.0f%%", msgid="extract.permissions"
+            )
+            while dirs:
+                pi.show()
+                dir_item = dirs.pop(-1)
+                try:
+                    archive.extract_item(dir_item, stdout=stdout)
+                except BackupOSError as e:
+                    self.print_warning("%s: %s", remove_surrogates(dir_item.path), e)
+        for pattern in matcher.get_unmatched_include_patterns():
+            self.print_warning("Include pattern '%s' never matched.", pattern)
+        if pi:
+            # clear progress output
+            pi.finish()
+        return self.exit_code
+
+    def build_parser_extract(self, subparsers, common_parser, mid_common_parser):
+
+        from .common import process_epilog
+        from .common import define_exclusion_group
+
+        extract_epilog = process_epilog(
+            """
+        This command extracts the contents of an archive. By default the entire
+        archive is extracted but a subset of files and directories can be selected
+        by passing a list of ``PATHs`` as arguments. The file selection can further
+        be restricted by using the ``--exclude`` option.
+
+        For more help on include/exclude patterns, see the :ref:`borg_patterns` command output.
+
+        By using ``--dry-run``, you can do all extraction steps except actually writing the
+        output data: reading metadata and data chunks from the repo, checking the hash/hmac,
+        decrypting, decompressing.
+
+        ``--progress`` can be slower than no progress display, since it makes one additional
+        pass over the archive metadata.
+
+        .. note::
+
+            Currently, extract always writes into the current working directory ("."),
+            so make sure you ``cd`` to the right place before calling ``borg extract``.
+
+            When parent directories are not extracted (because of using file/directory selection
+            or any other reason), borg can not restore parent directories' metadata, e.g. owner,
+            group, permission, etc.
+        """
+        )
+        subparser = subparsers.add_parser(
+            "extract",
+            parents=[common_parser],
+            add_help=False,
+            description=self.do_extract.__doc__,
+            epilog=extract_epilog,
+            formatter_class=argparse.RawDescriptionHelpFormatter,
+            help="extract archive contents",
+        )
+        subparser.set_defaults(func=self.do_extract)
+        subparser.add_argument(
+            "--list", dest="output_list", action="store_true", help="output verbose list of items (files, dirs, ...)"
+        )
+        subparser.add_argument(
+            "-n", "--dry-run", dest="dry_run", action="store_true", help="do not actually change any files"
+        )
+        subparser.add_argument(
+            "--numeric-ids",
+            dest="numeric_ids",
+            action="store_true",
+            help="only obey numeric user and group identifiers",
+        )
+        subparser.add_argument(
+            "--noflags", dest="noflags", action="store_true", help="do not extract/set flags (e.g. NODUMP, IMMUTABLE)"
+        )
+        subparser.add_argument("--noacls", dest="noacls", action="store_true", help="do not extract/set ACLs")
+        subparser.add_argument("--noxattrs", dest="noxattrs", action="store_true", help="do not extract/set xattrs")
+        subparser.add_argument(
+            "--stdout", dest="stdout", action="store_true", help="write all extracted data to stdout"
+        )
+        subparser.add_argument(
+            "--sparse",
+            dest="sparse",
+            action="store_true",
+            help="create holes in output sparse file from all-zero chunks",
+        )
+        subparser.add_argument("name", metavar="NAME", type=NameSpec, help="specify the archive name")
+        subparser.add_argument(
+            "paths", metavar="PATH", nargs="*", type=str, help="paths to extract; patterns are supported"
+        )
+        define_exclusion_group(subparser, strip_components=True)

From c871dbd8a5e168c3a7fbb73085b88d8b89ced61c Mon Sep 17 00:00:00 2001
From: Thomas Waldmann <tw@waldmann-edv.de>
Date: Sat, 9 Jul 2022 02:48:55 +0200
Subject: [PATCH 143/160] move recreate command to archiver.recreate

---
 setup.cfg                     |   1 +
 src/borg/archiver/__init__.py | 215 +-------------------------------
 src/borg/archiver/recreate.py | 225 ++++++++++++++++++++++++++++++++++
 3 files changed, 232 insertions(+), 209 deletions(-)
 create mode 100644 src/borg/archiver/recreate.py

diff --git a/setup.cfg b/setup.cfg
index bf7dbb322..29ecb1428 100644
--- a/setup.cfg
+++ b/setup.cfg
@@ -126,6 +126,7 @@ per_file_ignores =
     src/borg/archiver/help.py:E501,F405
     src/borg/archiver/keys.py:F405
     src/borg/archiver/prune.py:F405
+    src/borg/archiver/recreate.py:F405
     src/borg/archiver/rdelete.py:F405
     src/borg/archiver/rlist.py:E501
     src/borg/archiver/tar.py:F405
diff --git a/src/borg/archiver/__init__.py b/src/borg/archiver/__init__.py
index ac20c2dae..b833a2c83 100644
--- a/src/borg/archiver/__init__.py
+++ b/src/borg/archiver/__init__.py
@@ -25,10 +25,9 @@ try:
     logger = create_logger()
 
     from .common import with_repository, Highlander
-    from .common import build_matcher
     from .. import __version__
     from .. import helpers
-    from ..archive import Archive, ArchiveRecreater, is_special
+    from ..archive import Archive, is_special
     from ..archive import BackupError, BackupOSError, backup_io, OsOpen, stat_update_check
     from ..archive import FilesystemObjectProcessors, MetadataCollector, ChunksProcessor
     from ..cache import Cache
@@ -36,7 +35,7 @@ try:
     from ..compress import CompressionSpec
     from ..helpers import EXIT_SUCCESS, EXIT_WARNING, EXIT_ERROR, EXIT_SIGNAL_BASE
     from ..helpers import Error, set_ec
-    from ..helpers import location_validator, archivename_validator, ChunkerParams, Location
+    from ..helpers import location_validator, ChunkerParams, Location
     from ..helpers import NameSpec, CommentSpec, FilesCacheMode
     from ..helpers import format_file_size
     from ..helpers import remove_surrogates, eval_escapes
@@ -100,6 +99,7 @@ from .list_cmd import ListMixIn
 from .locks import LocksMixIn
 from .mount import MountMixIn
 from .prune import PruneMixIn
+from .recreate import RecreateMixIn
 from .rename import RenameMixIn
 from .rcreate import RCreateMixIn
 from .rinfo import RInfoMixIn
@@ -127,6 +127,7 @@ class Archiver(
     PruneMixIn,
     HelpMixIn,
     InfoMixIn,
+    RecreateMixIn,
     RenameMixIn,
     RCreateMixIn,
     RInfoMixIn,
@@ -595,52 +596,6 @@ class Archiver(
         if not recurse_excluded_dir:
             self.print_file_status(status, path)
 
-    @with_repository(cache=True, exclusive=True, compatibility=(Manifest.Operation.CHECK,))
-    def do_recreate(self, args, repository, manifest, key, cache):
-        """Re-create archives"""
-        matcher = build_matcher(args.patterns, args.paths)
-        self.output_list = args.output_list
-        self.output_filter = args.output_filter
-        recompress = args.recompress != "never"
-        always_recompress = args.recompress == "always"
-
-        recreater = ArchiveRecreater(
-            repository,
-            manifest,
-            key,
-            cache,
-            matcher,
-            exclude_caches=args.exclude_caches,
-            exclude_if_present=args.exclude_if_present,
-            keep_exclude_tags=args.keep_exclude_tags,
-            chunker_params=args.chunker_params,
-            compression=args.compression,
-            recompress=recompress,
-            always_recompress=always_recompress,
-            progress=args.progress,
-            stats=args.stats,
-            file_status_printer=self.print_file_status,
-            checkpoint_interval=args.checkpoint_interval,
-            dry_run=args.dry_run,
-            timestamp=args.timestamp,
-        )
-
-        archive_names = tuple(archive.name for archive in manifest.archives.list_considering(args))
-        if args.target is not None and len(archive_names) != 1:
-            self.print_error("--target: Need to specify single archive")
-            return self.exit_code
-        for name in archive_names:
-            if recreater.is_temporary_archive(name):
-                continue
-            print("Processing", name)
-            if not recreater.recreate(name, args.comment, args.target):
-                logger.info("Skipped archive %s: Nothing to do. Archive was not processed.", name)
-        if not args.dry_run:
-            manifest.write()
-            repository.commit(compact=False)
-            cache.commit()
-        return self.exit_code
-
     def preprocess_args(self, args):
         deprecations = [
             # ('--old', '--new' or None, 'Warning: "--old" has been deprecated. Use "--new" instead.'),
@@ -784,7 +739,7 @@ class Archiver(
     def build_parser(self):
 
         from .common import process_epilog
-        from .common import define_exclusion_group, define_archive_filters_group
+        from .common import define_exclusion_group
 
         def define_common_options(add_common_option):
             add_common_option("-h", "--help", action="help", help="show this help message and exit")
@@ -1352,165 +1307,7 @@ class Archiver(
         self.build_parser_keys(subparsers, common_parser, mid_common_parser)
         self.build_parser_rcreate(subparsers, common_parser, mid_common_parser)
 
-        # borg recreate
-        recreate_epilog = process_epilog(
-            """
-        Recreate the contents of existing archives.
-
-        recreate is a potentially dangerous function and might lead to data loss
-        (if used wrongly). BE VERY CAREFUL!
-
-        Important: Repository disk space is **not** freed until you run ``borg compact``.
-
-        ``--exclude``, ``--exclude-from``, ``--exclude-if-present``, ``--keep-exclude-tags``
-        and PATH have the exact same semantics as in "borg create", but they only check
-        for files in the archives and not in the local file system. If PATHs are specified,
-        the resulting archives will only contain files from these PATHs.
-
-        Note that all paths in an archive are relative, therefore absolute patterns/paths
-        will *not* match (``--exclude``, ``--exclude-from``, PATHs).
-
-        ``--recompress`` allows one to change the compression of existing data in archives.
-        Due to how Borg stores compressed size information this might display
-        incorrect information for archives that were not recreated at the same time.
-        There is no risk of data loss by this.
-
-        ``--chunker-params`` will re-chunk all files in the archive, this can be
-        used to have upgraded Borg 0.xx or Attic archives deduplicate with
-        Borg 1.x archives.
-
-        **USE WITH CAUTION.**
-        Depending on the PATHs and patterns given, recreate can be used to permanently
-        delete files from archives.
-        When in doubt, use ``--dry-run --verbose --list`` to see how patterns/PATHS are
-        interpreted. See :ref:`list_item_flags` in ``borg create`` for details.
-
-        The archive being recreated is only removed after the operation completes. The
-        archive that is built during the operation exists at the same time at
-        "<ARCHIVE>.recreate". The new archive will have a different archive ID.
-
-        With ``--target`` the original archive is not replaced, instead a new archive is created.
-
-        When rechunking (or recompressing), space usage can be substantial - expect
-        at least the entire deduplicated size of the archives using the previous
-        chunker (or compression) params.
-
-        If you recently ran borg check --repair and it had to fix lost chunks with all-zero
-        replacement chunks, please first run another backup for the same data and re-run
-        borg check --repair afterwards to heal any archives that had lost chunks which are
-        still generated from the input data.
-
-        Important: running borg recreate to re-chunk will remove the chunks_healthy
-        metadata of all items with replacement chunks, so healing will not be possible
-        any more after re-chunking (it is also unlikely it would ever work: due to the
-        change of chunking parameters, the missing chunk likely will never be seen again
-        even if you still have the data that produced it).
-        """
-        )
-        subparser = subparsers.add_parser(
-            "recreate",
-            parents=[common_parser],
-            add_help=False,
-            description=self.do_recreate.__doc__,
-            epilog=recreate_epilog,
-            formatter_class=argparse.RawDescriptionHelpFormatter,
-            help=self.do_recreate.__doc__,
-        )
-        subparser.set_defaults(func=self.do_recreate)
-        subparser.add_argument(
-            "--list", dest="output_list", action="store_true", help="output verbose list of items (files, dirs, ...)"
-        )
-        subparser.add_argument(
-            "--filter",
-            metavar="STATUSCHARS",
-            dest="output_filter",
-            action=Highlander,
-            help="only display items with the given status characters (listed in borg create --help)",
-        )
-        subparser.add_argument("-n", "--dry-run", dest="dry_run", action="store_true", help="do not change anything")
-        subparser.add_argument("-s", "--stats", dest="stats", action="store_true", help="print statistics at end")
-
-        define_exclusion_group(subparser, tag_files=True)
-
-        archive_group = define_archive_filters_group(subparser)
-        archive_group.add_argument(
-            "--target",
-            dest="target",
-            metavar="TARGET",
-            default=None,
-            type=archivename_validator(),
-            help="create a new archive with the name ARCHIVE, do not replace existing archive "
-            "(only applies for a single archive)",
-        )
-        archive_group.add_argument(
-            "-c",
-            "--checkpoint-interval",
-            dest="checkpoint_interval",
-            type=int,
-            default=1800,
-            metavar="SECONDS",
-            help="write checkpoint every SECONDS seconds (Default: 1800)",
-        )
-        archive_group.add_argument(
-            "--comment",
-            dest="comment",
-            metavar="COMMENT",
-            type=CommentSpec,
-            default=None,
-            help="add a comment text to the archive",
-        )
-        archive_group.add_argument(
-            "--timestamp",
-            metavar="TIMESTAMP",
-            dest="timestamp",
-            type=timestamp,
-            default=None,
-            help="manually specify the archive creation date/time (UTC, yyyy-mm-ddThh:mm:ss format). "
-            "alternatively, give a reference file/directory.",
-        )
-        archive_group.add_argument(
-            "-C",
-            "--compression",
-            metavar="COMPRESSION",
-            dest="compression",
-            type=CompressionSpec,
-            default=CompressionSpec("lz4"),
-            help="select compression algorithm, see the output of the " '"borg help compression" command for details.',
-        )
-        archive_group.add_argument(
-            "--recompress",
-            metavar="MODE",
-            dest="recompress",
-            nargs="?",
-            default="never",
-            const="if-different",
-            choices=("never", "if-different", "always"),
-            help="recompress data chunks according to `MODE` and ``--compression``. "
-            "Possible modes are "
-            "`if-different`: recompress if current compression is with a different "
-            "compression algorithm or different level; "
-            "`always`: recompress unconditionally; and "
-            "`never`: do not recompress (use this option to explicitly prevent "
-            "recompression). "
-            "If no MODE is given, `if-different` will be used. "
-            'Not passing --recompress is equivalent to "--recompress never".',
-        )
-        archive_group.add_argument(
-            "--chunker-params",
-            metavar="PARAMS",
-            dest="chunker_params",
-            action=Highlander,
-            type=ChunkerParams,
-            default=CHUNKER_PARAMS,
-            help="specify the chunker parameters (ALGO, CHUNK_MIN_EXP, CHUNK_MAX_EXP, "
-            "HASH_MASK_BITS, HASH_WINDOW_SIZE) or `default` to use the current defaults. "
-            "default: %s,%d,%d,%d,%d" % CHUNKER_PARAMS,
-        )
-
-        subparser.add_argument(
-            "paths", metavar="PATH", nargs="*", type=str, help="paths to recreate; patterns are supported"
-        )
-
+        self.build_parser_recreate(subparsers, common_parser, mid_common_parser)
         self.build_parser_rename(subparsers, common_parser, mid_common_parser)
         self.build_parser_serve(subparsers, common_parser, mid_common_parser)
         self.build_parser_tar(subparsers, common_parser, mid_common_parser)
diff --git a/src/borg/archiver/recreate.py b/src/borg/archiver/recreate.py
new file mode 100644
index 000000000..0aef1d29b
--- /dev/null
+++ b/src/borg/archiver/recreate.py
@@ -0,0 +1,225 @@
+import argparse
+
+from .common import with_repository, Highlander
+from .common import build_matcher
+from ..archive import ArchiveRecreater
+from ..constants import *  # NOQA
+from ..compress import CompressionSpec
+from ..helpers import archivename_validator, ChunkerParams
+from ..helpers import CommentSpec
+from ..helpers import timestamp
+from ..helpers import Manifest
+
+from ..logger import create_logger
+
+logger = create_logger()
+
+
+class RecreateMixIn:
+    @with_repository(cache=True, exclusive=True, compatibility=(Manifest.Operation.CHECK,))
+    def do_recreate(self, args, repository, manifest, key, cache):
+        """Re-create archives"""
+        matcher = build_matcher(args.patterns, args.paths)
+        self.output_list = args.output_list
+        self.output_filter = args.output_filter
+        recompress = args.recompress != "never"
+        always_recompress = args.recompress == "always"
+
+        recreater = ArchiveRecreater(
+            repository,
+            manifest,
+            key,
+            cache,
+            matcher,
+            exclude_caches=args.exclude_caches,
+            exclude_if_present=args.exclude_if_present,
+            keep_exclude_tags=args.keep_exclude_tags,
+            chunker_params=args.chunker_params,
+            compression=args.compression,
+            recompress=recompress,
+            always_recompress=always_recompress,
+            progress=args.progress,
+            stats=args.stats,
+            file_status_printer=self.print_file_status,
+            checkpoint_interval=args.checkpoint_interval,
+            dry_run=args.dry_run,
+            timestamp=args.timestamp,
+        )
+
+        archive_names = tuple(archive.name for archive in manifest.archives.list_considering(args))
+        if args.target is not None and len(archive_names) != 1:
+            self.print_error("--target: Need to specify single archive")
+            return self.exit_code
+        for name in archive_names:
+            if recreater.is_temporary_archive(name):
+                continue
+            print("Processing", name)
+            if not recreater.recreate(name, args.comment, args.target):
+                logger.info("Skipped archive %s: Nothing to do. Archive was not processed.", name)
+        if not args.dry_run:
+            manifest.write()
+            repository.commit(compact=False)
+            cache.commit()
+        return self.exit_code
+
+    def build_parser_recreate(self, subparsers, common_parser, mid_common_parser):
+        from .common import process_epilog
+        from .common import define_exclusion_group, define_archive_filters_group
+
+        recreate_epilog = process_epilog(
+            """
+        Recreate the contents of existing archives.
+
+        recreate is a potentially dangerous function and might lead to data loss
+        (if used wrongly). BE VERY CAREFUL!
+
+        Important: Repository disk space is **not** freed until you run ``borg compact``.
+
+        ``--exclude``, ``--exclude-from``, ``--exclude-if-present``, ``--keep-exclude-tags``
+        and PATH have the exact same semantics as in "borg create", but they only check
+        for files in the archives and not in the local file system. If PATHs are specified,
+        the resulting archives will only contain files from these PATHs.
+
+        Note that all paths in an archive are relative, therefore absolute patterns/paths
+        will *not* match (``--exclude``, ``--exclude-from``, PATHs).
+
+        ``--recompress`` allows one to change the compression of existing data in archives.
+        Due to how Borg stores compressed size information this might display
+        incorrect information for archives that were not recreated at the same time.
+        There is no risk of data loss by this.
+
+        ``--chunker-params`` will re-chunk all files in the archive, this can be
+        used to have upgraded Borg 0.xx or Attic archives deduplicate with
+        Borg 1.x archives.
+
+        **USE WITH CAUTION.**
+        Depending on the PATHs and patterns given, recreate can be used to permanently
+        delete files from archives.
+        When in doubt, use ``--dry-run --verbose --list`` to see how patterns/PATHS are
+        interpreted. See :ref:`list_item_flags` in ``borg create`` for details.
+
+        The archive being recreated is only removed after the operation completes. The
+        archive that is built during the operation exists at the same time at
+        "<ARCHIVE>.recreate". The new archive will have a different archive ID.
+
+        With ``--target`` the original archive is not replaced, instead a new archive is created.
+
+        When rechunking (or recompressing), space usage can be substantial - expect
+        at least the entire deduplicated size of the archives using the previous
+        chunker (or compression) params.
+
+        If you recently ran borg check --repair and it had to fix lost chunks with all-zero
+        replacement chunks, please first run another backup for the same data and re-run
+        borg check --repair afterwards to heal any archives that had lost chunks which are
+        still generated from the input data.
+
+        Important: running borg recreate to re-chunk will remove the chunks_healthy
+        metadata of all items with replacement chunks, so healing will not be possible
+        any more after re-chunking (it is also unlikely it would ever work: due to the
+        change of chunking parameters, the missing chunk likely will never be seen again
+        even if you still have the data that produced it).
+        """
+        )
+        subparser = subparsers.add_parser(
+            "recreate",
+            parents=[common_parser],
+            add_help=False,
+            description=self.do_recreate.__doc__,
+            epilog=recreate_epilog,
+            formatter_class=argparse.RawDescriptionHelpFormatter,
+            help=self.do_recreate.__doc__,
+        )
+        subparser.set_defaults(func=self.do_recreate)
+        subparser.add_argument(
+            "--list", dest="output_list", action="store_true", help="output verbose list of items (files, dirs, ...)"
+        )
+        subparser.add_argument(
+            "--filter",
+            metavar="STATUSCHARS",
+            dest="output_filter",
+            action=Highlander,
+            help="only display items with the given status characters (listed in borg create --help)",
+        )
+        subparser.add_argument("-n", "--dry-run", dest="dry_run", action="store_true", help="do not change anything")
+        subparser.add_argument("-s", "--stats", dest="stats", action="store_true", help="print statistics at end")
+
+        define_exclusion_group(subparser, tag_files=True)
+
+        archive_group = define_archive_filters_group(subparser)
+        archive_group.add_argument(
+            "--target",
+            dest="target",
+            metavar="TARGET",
+            default=None,
+            type=archivename_validator(),
+            help="create a new archive with the name ARCHIVE, do not replace existing archive "
+            "(only applies for a single archive)",
+        )
+        archive_group.add_argument(
+            "-c",
+            "--checkpoint-interval",
+            dest="checkpoint_interval",
+            type=int,
+            default=1800,
+            metavar="SECONDS",
+            help="write checkpoint every SECONDS seconds (Default: 1800)",
+        )
+        archive_group.add_argument(
+            "--comment",
+            dest="comment",
+            metavar="COMMENT",
+            type=CommentSpec,
+            default=None,
+            help="add a comment text to the archive",
+        )
+        archive_group.add_argument(
+            "--timestamp",
+            metavar="TIMESTAMP",
+            dest="timestamp",
+            type=timestamp,
+            default=None,
+            help="manually specify the archive creation date/time (UTC, yyyy-mm-ddThh:mm:ss format). "
+            "alternatively, give a reference file/directory.",
+        )
+        archive_group.add_argument(
+            "-C",
+            "--compression",
+            metavar="COMPRESSION",
+            dest="compression",
+            type=CompressionSpec,
+            default=CompressionSpec("lz4"),
+            help="select compression algorithm, see the output of the " '"borg help compression" command for details.',
+        )
+        archive_group.add_argument(
+            "--recompress",
+            metavar="MODE",
+            dest="recompress",
+            nargs="?",
+            default="never",
+            const="if-different",
+            choices=("never", "if-different", "always"),
+            help="recompress data chunks according to `MODE` and ``--compression``. "
+            "Possible modes are "
+            "`if-different`: recompress if current compression is with a different "
+            "compression algorithm or different level; "
+            "`always`: recompress unconditionally; and "
+            "`never`: do not recompress (use this option to explicitly prevent "
+            "recompression). "
+            "If no MODE is given, `if-different` will be used. "
+            'Not passing --recompress is equivalent to "--recompress never".',
+        )
+        archive_group.add_argument(
+            "--chunker-params",
+            metavar="PARAMS",
+            dest="chunker_params",
+            action=Highlander,
+            type=ChunkerParams,
+            default=CHUNKER_PARAMS,
+            help="specify the chunker parameters (ALGO, CHUNK_MIN_EXP, CHUNK_MAX_EXP, "
+            "HASH_MASK_BITS, HASH_WINDOW_SIZE) or `default` to use the current defaults. "
+            "default: %s,%d,%d,%d,%d" % CHUNKER_PARAMS,
+        )
+
+        subparser.add_argument(
+            "paths", metavar="PATH", nargs="*", type=str, help="paths to recreate; patterns are supported"
+        )

From 70b54a696fa06efd8a964c001a203111159cbf12 Mon Sep 17 00:00:00 2001
From: Thomas Waldmann <tw@waldmann-edv.de>
Date: Sat, 9 Jul 2022 03:11:16 +0200
Subject: [PATCH 144/160] move create command to archiver.create

---
 setup.cfg                     |   1 +
 src/borg/archiver/__init__.py | 850 +--------------------------------
 src/borg/archiver/create.py   | 857 ++++++++++++++++++++++++++++++++++
 3 files changed, 864 insertions(+), 844 deletions(-)
 create mode 100644 src/borg/archiver/create.py

diff --git a/setup.cfg b/setup.cfg
index 29ecb1428..2763d4434 100644
--- a/setup.cfg
+++ b/setup.cfg
@@ -120,6 +120,7 @@ per_file_ignores =
     src/borg/archiver/benchmarks.py:F405
     src/borg/archiver/config.py:F405,E722
     src/borg/archiver/common.py:E501,F405
+    src/borg/archiver/create.py:E501,F405
     src/borg/archiver/debug.py:F405
     src/borg/archiver/delete.py:F405
     src/borg/archiver/diff.py:F405
diff --git a/src/borg/archiver/__init__.py b/src/borg/archiver/__init__.py
index b833a2c83..701acbe37 100644
--- a/src/borg/archiver/__init__.py
+++ b/src/borg/archiver/__init__.py
@@ -14,47 +14,25 @@ try:
     import os
     import shlex
     import signal
-    import stat
-    import subprocess
-    import time
     from datetime import datetime
-    from io import TextIOWrapper
 
     from ..logger import create_logger, setup_logging
 
     logger = create_logger()
 
-    from .common import with_repository, Highlander
     from .. import __version__
-    from .. import helpers
-    from ..archive import Archive, is_special
-    from ..archive import BackupError, BackupOSError, backup_io, OsOpen, stat_update_check
-    from ..archive import FilesystemObjectProcessors, MetadataCollector, ChunksProcessor
-    from ..cache import Cache
     from ..constants import *  # NOQA
-    from ..compress import CompressionSpec
     from ..helpers import EXIT_SUCCESS, EXIT_WARNING, EXIT_ERROR, EXIT_SIGNAL_BASE
     from ..helpers import Error, set_ec
-    from ..helpers import location_validator, ChunkerParams, Location
-    from ..helpers import NameSpec, CommentSpec, FilesCacheMode
+    from ..helpers import location_validator, Location
     from ..helpers import format_file_size
-    from ..helpers import remove_surrogates, eval_escapes
-    from ..helpers import timestamp
-    from ..helpers import get_cache_dir, os_stat
-    from ..helpers import Manifest
+    from ..helpers import remove_surrogates
     from ..helpers import check_python, check_extension_modules
-    from ..helpers import dir_is_tagged, is_slow_msgpack, is_supported_msgpack, sysinfo
-    from ..helpers import log_multi
+    from ..helpers import is_slow_msgpack, is_supported_msgpack, sysinfo
     from ..helpers import signal_handler, raising_signal_handler, SigHup, SigTerm
     from ..helpers import ErrorIgnoringTextIOWrapper
-    from ..helpers import basic_json_data, json_print
-    from ..helpers import flags_root, flags_dir, flags_special_follow, flags_special
     from ..helpers import msgpack
     from ..helpers import sig_int
-    from ..helpers import iter_separated
-    from ..patterns import PatternMatcher
-    from ..platform import get_flags
-    from ..platform import uid2user, gid2group
     from ..remote import RemoteRepository
     from ..selftest import selftest
 except BaseException:
@@ -88,6 +66,7 @@ from .benchmarks import BenchmarkMixIn
 from .check import CheckMixIn
 from .compact import CompactMixIn
 from .config import ConfigMixIn
+from .create import CreateMixIn
 from .debug import DebugMixIn
 from .delete import DeleteMixIn
 from .diff import DiffMixIn
@@ -114,6 +93,7 @@ class Archiver(
     CheckMixIn,
     ConfigMixIn,
     CompactMixIn,
+    CreateMixIn,
     DebugMixIn,
     DeleteMixIn,
     DiffMixIn,
@@ -162,440 +142,6 @@ class Archiver(
             else:
                 logging.getLogger("borg.output.list").info("%1s %s", status, remove_surrogates(path))
 
-    @with_repository(fake="dry_run", exclusive=True, compatibility=(Manifest.Operation.WRITE,))
-    def do_create(self, args, repository, manifest=None, key=None):
-        """Create new archive"""
-        matcher = PatternMatcher(fallback=True)
-        matcher.add_inclexcl(args.patterns)
-
-        def create_inner(archive, cache, fso):
-            # Add cache dir to inode_skip list
-            skip_inodes = set()
-            try:
-                st = os.stat(get_cache_dir())
-                skip_inodes.add((st.st_ino, st.st_dev))
-            except OSError:
-                pass
-            # Add local repository dir to inode_skip list
-            if not args.location.host:
-                try:
-                    st = os.stat(args.location.path)
-                    skip_inodes.add((st.st_ino, st.st_dev))
-                except OSError:
-                    pass
-            logger.debug("Processing files ...")
-            if args.content_from_command:
-                path = args.stdin_name
-                mode = args.stdin_mode
-                user = args.stdin_user
-                group = args.stdin_group
-                if not dry_run:
-                    try:
-                        try:
-                            proc = subprocess.Popen(args.paths, stdout=subprocess.PIPE)
-                        except (FileNotFoundError, PermissionError) as e:
-                            self.print_error("Failed to execute command: %s", e)
-                            return self.exit_code
-                        status = fso.process_pipe(
-                            path=path, cache=cache, fd=proc.stdout, mode=mode, user=user, group=group
-                        )
-                        rc = proc.wait()
-                        if rc != 0:
-                            self.print_error("Command %r exited with status %d", args.paths[0], rc)
-                            return self.exit_code
-                    except BackupOSError as e:
-                        self.print_error("%s: %s", path, e)
-                        return self.exit_code
-                else:
-                    status = "-"
-                self.print_file_status(status, path)
-            elif args.paths_from_command or args.paths_from_stdin:
-                paths_sep = eval_escapes(args.paths_delimiter) if args.paths_delimiter is not None else "\n"
-                if args.paths_from_command:
-                    try:
-                        proc = subprocess.Popen(args.paths, stdout=subprocess.PIPE)
-                    except (FileNotFoundError, PermissionError) as e:
-                        self.print_error("Failed to execute command: %s", e)
-                        return self.exit_code
-                    pipe_bin = proc.stdout
-                else:  # args.paths_from_stdin == True
-                    pipe_bin = sys.stdin.buffer
-                pipe = TextIOWrapper(pipe_bin, errors="surrogateescape")
-                for path in iter_separated(pipe, paths_sep):
-                    path = os.path.normpath(path)
-                    try:
-                        with backup_io("stat"):
-                            st = os_stat(path=path, parent_fd=None, name=None, follow_symlinks=False)
-                        status = self._process_any(
-                            path=path,
-                            parent_fd=None,
-                            name=None,
-                            st=st,
-                            fso=fso,
-                            cache=cache,
-                            read_special=args.read_special,
-                            dry_run=dry_run,
-                        )
-                    except (BackupOSError, BackupError) as e:
-                        self.print_warning("%s: %s", path, e)
-                        status = "E"
-                    if status == "C":
-                        self.print_warning("%s: file changed while we backed it up", path)
-                    self.print_file_status(status, path)
-                if args.paths_from_command:
-                    rc = proc.wait()
-                    if rc != 0:
-                        self.print_error("Command %r exited with status %d", args.paths[0], rc)
-                        return self.exit_code
-            else:
-                for path in args.paths:
-                    if path == "-":  # stdin
-                        path = args.stdin_name
-                        mode = args.stdin_mode
-                        user = args.stdin_user
-                        group = args.stdin_group
-                        if not dry_run:
-                            try:
-                                status = fso.process_pipe(
-                                    path=path, cache=cache, fd=sys.stdin.buffer, mode=mode, user=user, group=group
-                                )
-                            except BackupOSError as e:
-                                status = "E"
-                                self.print_warning("%s: %s", path, e)
-                        else:
-                            status = "-"
-                        self.print_file_status(status, path)
-                        continue
-                    path = os.path.normpath(path)
-                    parent_dir = os.path.dirname(path) or "."
-                    name = os.path.basename(path)
-                    try:
-                        # note: for path == '/':  name == '' and parent_dir == '/'.
-                        # the empty name will trigger a fall-back to path-based processing in os_stat and os_open.
-                        with OsOpen(path=parent_dir, flags=flags_root, noatime=True, op="open_root") as parent_fd:
-                            try:
-                                st = os_stat(path=path, parent_fd=parent_fd, name=name, follow_symlinks=False)
-                            except OSError as e:
-                                self.print_warning("%s: %s", path, e)
-                                continue
-                            if args.one_file_system:
-                                restrict_dev = st.st_dev
-                            else:
-                                restrict_dev = None
-                            self._rec_walk(
-                                path=path,
-                                parent_fd=parent_fd,
-                                name=name,
-                                fso=fso,
-                                cache=cache,
-                                matcher=matcher,
-                                exclude_caches=args.exclude_caches,
-                                exclude_if_present=args.exclude_if_present,
-                                keep_exclude_tags=args.keep_exclude_tags,
-                                skip_inodes=skip_inodes,
-                                restrict_dev=restrict_dev,
-                                read_special=args.read_special,
-                                dry_run=dry_run,
-                            )
-                            # if we get back here, we've finished recursing into <path>,
-                            # we do not ever want to get back in there (even if path is given twice as recursion root)
-                            skip_inodes.add((st.st_ino, st.st_dev))
-                    except (BackupOSError, BackupError) as e:
-                        # this comes from OsOpen, self._rec_walk has own exception handler
-                        self.print_warning("%s: %s", path, e)
-                        continue
-            if not dry_run:
-                if args.progress:
-                    archive.stats.show_progress(final=True)
-                archive.stats += fso.stats
-                if sig_int:
-                    # do not save the archive if the user ctrl-c-ed - it is valid, but incomplete.
-                    # we already have a checkpoint archive in this case.
-                    self.print_error("Got Ctrl-C / SIGINT.")
-                else:
-                    archive.save(comment=args.comment, timestamp=args.timestamp, stats=archive.stats)
-                    args.stats |= args.json
-                    if args.stats:
-                        if args.json:
-                            json_print(basic_json_data(manifest, cache=cache, extra={"archive": archive}))
-                        else:
-                            log_multi(str(archive), str(archive.stats), logger=logging.getLogger("borg.output.stats"))
-
-        self.output_filter = args.output_filter
-        self.output_list = args.output_list
-        self.noflags = args.noflags
-        self.noacls = args.noacls
-        self.noxattrs = args.noxattrs
-        self.exclude_nodump = args.exclude_nodump
-        dry_run = args.dry_run
-        t0 = datetime.utcnow()
-        t0_monotonic = time.monotonic()
-        logger.info('Creating archive at "%s"' % args.location.processed)
-        if not dry_run:
-            with Cache(
-                repository,
-                key,
-                manifest,
-                progress=args.progress,
-                lock_wait=self.lock_wait,
-                permit_adhoc_cache=args.no_cache_sync,
-                cache_mode=args.files_cache_mode,
-                iec=args.iec,
-            ) as cache:
-                archive = Archive(
-                    repository,
-                    key,
-                    manifest,
-                    args.name,
-                    cache=cache,
-                    create=True,
-                    checkpoint_interval=args.checkpoint_interval,
-                    numeric_ids=args.numeric_ids,
-                    noatime=not args.atime,
-                    noctime=args.noctime,
-                    progress=args.progress,
-                    chunker_params=args.chunker_params,
-                    start=t0,
-                    start_monotonic=t0_monotonic,
-                    log_json=args.log_json,
-                    iec=args.iec,
-                )
-                metadata_collector = MetadataCollector(
-                    noatime=not args.atime,
-                    noctime=args.noctime,
-                    noflags=args.noflags,
-                    noacls=args.noacls,
-                    noxattrs=args.noxattrs,
-                    numeric_ids=args.numeric_ids,
-                    nobirthtime=args.nobirthtime,
-                )
-                cp = ChunksProcessor(
-                    cache=cache,
-                    key=key,
-                    add_item=archive.add_item,
-                    write_checkpoint=archive.write_checkpoint,
-                    checkpoint_interval=args.checkpoint_interval,
-                    rechunkify=False,
-                )
-                fso = FilesystemObjectProcessors(
-                    metadata_collector=metadata_collector,
-                    cache=cache,
-                    key=key,
-                    process_file_chunks=cp.process_file_chunks,
-                    add_item=archive.add_item,
-                    chunker_params=args.chunker_params,
-                    show_progress=args.progress,
-                    sparse=args.sparse,
-                    log_json=args.log_json,
-                    iec=args.iec,
-                    file_status_printer=self.print_file_status,
-                )
-                create_inner(archive, cache, fso)
-        else:
-            create_inner(None, None, None)
-        return self.exit_code
-
-    def _process_any(self, *, path, parent_fd, name, st, fso, cache, read_special, dry_run):
-        """
-        Call the right method on the given FilesystemObjectProcessor.
-        """
-
-        if dry_run:
-            return "-"
-        elif stat.S_ISREG(st.st_mode):
-            return fso.process_file(path=path, parent_fd=parent_fd, name=name, st=st, cache=cache)
-        elif stat.S_ISDIR(st.st_mode):
-            return fso.process_dir(path=path, parent_fd=parent_fd, name=name, st=st)
-        elif stat.S_ISLNK(st.st_mode):
-            if not read_special:
-                return fso.process_symlink(path=path, parent_fd=parent_fd, name=name, st=st)
-            else:
-                try:
-                    st_target = os_stat(path=path, parent_fd=parent_fd, name=name, follow_symlinks=True)
-                except OSError:
-                    special = False
-                else:
-                    special = is_special(st_target.st_mode)
-                if special:
-                    return fso.process_file(
-                        path=path, parent_fd=parent_fd, name=name, st=st_target, cache=cache, flags=flags_special_follow
-                    )
-                else:
-                    return fso.process_symlink(path=path, parent_fd=parent_fd, name=name, st=st)
-        elif stat.S_ISFIFO(st.st_mode):
-            if not read_special:
-                return fso.process_fifo(path=path, parent_fd=parent_fd, name=name, st=st)
-            else:
-                return fso.process_file(
-                    path=path, parent_fd=parent_fd, name=name, st=st, cache=cache, flags=flags_special
-                )
-        elif stat.S_ISCHR(st.st_mode):
-            if not read_special:
-                return fso.process_dev(path=path, parent_fd=parent_fd, name=name, st=st, dev_type="c")
-            else:
-                return fso.process_file(
-                    path=path, parent_fd=parent_fd, name=name, st=st, cache=cache, flags=flags_special
-                )
-        elif stat.S_ISBLK(st.st_mode):
-            if not read_special:
-                return fso.process_dev(path=path, parent_fd=parent_fd, name=name, st=st, dev_type="b")
-            else:
-                return fso.process_file(
-                    path=path, parent_fd=parent_fd, name=name, st=st, cache=cache, flags=flags_special
-                )
-        elif stat.S_ISSOCK(st.st_mode):
-            # Ignore unix sockets
-            return
-        elif stat.S_ISDOOR(st.st_mode):
-            # Ignore Solaris doors
-            return
-        elif stat.S_ISPORT(st.st_mode):
-            # Ignore Solaris event ports
-            return
-        else:
-            self.print_warning("Unknown file type: %s", path)
-            return
-
-    def _rec_walk(
-        self,
-        *,
-        path,
-        parent_fd,
-        name,
-        fso,
-        cache,
-        matcher,
-        exclude_caches,
-        exclude_if_present,
-        keep_exclude_tags,
-        skip_inodes,
-        restrict_dev,
-        read_special,
-        dry_run,
-    ):
-        """
-        Process *path* (or, preferably, parent_fd/name) recursively according to the various parameters.
-
-        This should only raise on critical errors. Per-item errors must be handled within this method.
-        """
-        if sig_int and sig_int.action_done():
-            # the user says "get out of here!" and we have already completed the desired action.
-            return
-
-        status = None
-        try:
-            recurse_excluded_dir = False
-            if matcher.match(path):
-                with backup_io("stat"):
-                    st = os_stat(path=path, parent_fd=parent_fd, name=name, follow_symlinks=False)
-            else:
-                self.print_file_status("x", path)
-                # get out here as quickly as possible:
-                # we only need to continue if we shall recurse into an excluded directory.
-                # if we shall not recurse, then do not even touch (stat()) the item, it
-                # could trigger an error, e.g. if access is forbidden, see #3209.
-                if not matcher.recurse_dir:
-                    return
-                recurse_excluded_dir = True
-                with backup_io("stat"):
-                    st = os_stat(path=path, parent_fd=parent_fd, name=name, follow_symlinks=False)
-                if not stat.S_ISDIR(st.st_mode):
-                    return
-
-            if (st.st_ino, st.st_dev) in skip_inodes:
-                return
-            # if restrict_dev is given, we do not want to recurse into a new filesystem,
-            # but we WILL save the mountpoint directory (or more precise: the root
-            # directory of the mounted filesystem that shadows the mountpoint dir).
-            recurse = restrict_dev is None or st.st_dev == restrict_dev
-
-            if self.exclude_nodump:
-                # Ignore if nodump flag is set
-                with backup_io("flags"):
-                    if get_flags(path=path, st=st) & stat.UF_NODUMP:
-                        self.print_file_status("x", path)
-                        return
-
-            if not stat.S_ISDIR(st.st_mode):
-                # directories cannot go in this branch because they can be excluded based on tag
-                # files they might contain
-                status = self._process_any(
-                    path=path,
-                    parent_fd=parent_fd,
-                    name=name,
-                    st=st,
-                    fso=fso,
-                    cache=cache,
-                    read_special=read_special,
-                    dry_run=dry_run,
-                )
-            else:
-                with OsOpen(
-                    path=path, parent_fd=parent_fd, name=name, flags=flags_dir, noatime=True, op="dir_open"
-                ) as child_fd:
-                    # child_fd is None for directories on windows, in that case a race condition check is not possible.
-                    if child_fd is not None:
-                        with backup_io("fstat"):
-                            st = stat_update_check(st, os.fstat(child_fd))
-                    if recurse:
-                        tag_names = dir_is_tagged(path, exclude_caches, exclude_if_present)
-                        if tag_names:
-                            # if we are already recursing in an excluded dir, we do not need to do anything else than
-                            # returning (we do not need to archive or recurse into tagged directories), see #3991:
-                            if not recurse_excluded_dir:
-                                if keep_exclude_tags:
-                                    if not dry_run:
-                                        fso.process_dir_with_fd(path=path, fd=child_fd, st=st)
-                                    for tag_name in tag_names:
-                                        tag_path = os.path.join(path, tag_name)
-                                        self._rec_walk(
-                                            path=tag_path,
-                                            parent_fd=child_fd,
-                                            name=tag_name,
-                                            fso=fso,
-                                            cache=cache,
-                                            matcher=matcher,
-                                            exclude_caches=exclude_caches,
-                                            exclude_if_present=exclude_if_present,
-                                            keep_exclude_tags=keep_exclude_tags,
-                                            skip_inodes=skip_inodes,
-                                            restrict_dev=restrict_dev,
-                                            read_special=read_special,
-                                            dry_run=dry_run,
-                                        )
-                                self.print_file_status("x", path)
-                            return
-                    if not recurse_excluded_dir and not dry_run:
-                        status = fso.process_dir_with_fd(path=path, fd=child_fd, st=st)
-                    if recurse:
-                        with backup_io("scandir"):
-                            entries = helpers.scandir_inorder(path=path, fd=child_fd)
-                        for dirent in entries:
-                            normpath = os.path.normpath(os.path.join(path, dirent.name))
-                            self._rec_walk(
-                                path=normpath,
-                                parent_fd=child_fd,
-                                name=dirent.name,
-                                fso=fso,
-                                cache=cache,
-                                matcher=matcher,
-                                exclude_caches=exclude_caches,
-                                exclude_if_present=exclude_if_present,
-                                keep_exclude_tags=keep_exclude_tags,
-                                skip_inodes=skip_inodes,
-                                restrict_dev=restrict_dev,
-                                read_special=read_special,
-                                dry_run=dry_run,
-                            )
-
-        except (BackupOSError, BackupError) as e:
-            self.print_warning("%s: %s", path, e)
-            status = "E"
-        if status == "C":
-            self.print_warning("%s: file changed while we backed it up", path)
-        if not recurse_excluded_dir:
-            self.print_file_status(status, path)
-
     def preprocess_args(self, args):
         deprecations = [
             # ('--old', '--new' or None, 'Warning: "--old" has been deprecated. Use "--new" instead.'),
@@ -737,10 +283,6 @@ class Archiver(
                 setattr(args, dest, option_value)
 
     def build_parser(self):
-
-        from .common import process_epilog
-        from .common import define_exclusion_group
-
         def define_common_options(add_common_option):
             add_common_option("-h", "--help", action="help", help="show this help message and exit")
             add_common_option(
@@ -908,393 +450,13 @@ class Archiver(
         self.build_parser_benchmarks(subparsers, common_parser, mid_common_parser)
         self.build_parser_check(subparsers, common_parser, mid_common_parser)
         self.build_parser_compact(subparsers, common_parser, mid_common_parser)
+        self.build_parser_create(subparsers, common_parser, mid_common_parser)
         self.build_parser_diff(subparsers, common_parser, mid_common_parser)
         self.build_parser_list(subparsers, common_parser, mid_common_parser)
         self.build_parser_locks(subparsers, common_parser, mid_common_parser)
         self.build_parser_mount_umount(subparsers, common_parser, mid_common_parser)
         self.build_parser_prune(subparsers, common_parser, mid_common_parser)
 
-        # borg create
-        create_epilog = process_epilog(
-            """
-        This command creates a backup archive containing all files found while recursively
-        traversing all paths specified. Paths are added to the archive as they are given,
-        that means if relative paths are desired, the command has to be run from the correct
-        directory.
-
-        When giving '-' as path, borg will read data from standard input and create a
-        file 'stdin' in the created archive from that data. In some cases it's more
-        appropriate to use --content-from-command, however. See section *Reading from
-        stdin* below for details.
-
-        The archive will consume almost no disk space for files or parts of files that
-        have already been stored in other archives.
-
-        The archive name needs to be unique. It must not end in '.checkpoint' or
-        '.checkpoint.N' (with N being a number), because these names are used for
-        checkpoints and treated in special ways.
-
-        In the archive name, you may use the following placeholders:
-        {now}, {utcnow}, {fqdn}, {hostname}, {user} and some others.
-
-        Backup speed is increased by not reprocessing files that are already part of
-        existing archives and weren't modified. The detection of unmodified files is
-        done by comparing multiple file metadata values with previous values kept in
-        the files cache.
-
-        This comparison can operate in different modes as given by ``--files-cache``:
-
-        - ctime,size,inode (default)
-        - mtime,size,inode (default behaviour of borg versions older than 1.1.0rc4)
-        - ctime,size (ignore the inode number)
-        - mtime,size (ignore the inode number)
-        - rechunk,ctime (all files are considered modified - rechunk, cache ctime)
-        - rechunk,mtime (all files are considered modified - rechunk, cache mtime)
-        - disabled (disable the files cache, all files considered modified - rechunk)
-
-        inode number: better safety, but often unstable on network filesystems
-
-        Normally, detecting file modifications will take inode information into
-        consideration to improve the reliability of file change detection.
-        This is problematic for files located on sshfs and similar network file
-        systems which do not provide stable inode numbers, such files will always
-        be considered modified. You can use modes without `inode` in this case to
-        improve performance, but reliability of change detection might be reduced.
-
-        ctime vs. mtime: safety vs. speed
-
-        - ctime is a rather safe way to detect changes to a file (metadata and contents)
-          as it can not be set from userspace. But, a metadata-only change will already
-          update the ctime, so there might be some unnecessary chunking/hashing even
-          without content changes. Some filesystems do not support ctime (change time).
-          E.g. doing a chown or chmod to a file will change its ctime.
-        - mtime usually works and only updates if file contents were changed. But mtime
-          can be arbitrarily set from userspace, e.g. to set mtime back to the same value
-          it had before a content change happened. This can be used maliciously as well as
-          well-meant, but in both cases mtime based cache modes can be problematic.
-
-        The mount points of filesystems or filesystem snapshots should be the same for every
-        creation of a new archive to ensure fast operation. This is because the file cache that
-        is used to determine changed files quickly uses absolute filenames.
-        If this is not possible, consider creating a bind mount to a stable location.
-
-        The ``--progress`` option shows (from left to right) Original, Compressed and Deduplicated
-        (O, C and D, respectively), then the Number of files (N) processed so far, followed by
-        the currently processed path.
-
-        When using ``--stats``, you will get some statistics about how much data was
-        added - the "This Archive" deduplicated size there is most interesting as that is
-        how much your repository will grow. Please note that the "All archives" stats refer to
-        the state after creation. Also, the ``--stats`` and ``--dry-run`` options are mutually
-        exclusive because the data is not actually compressed and deduplicated during a dry run.
-
-        For more help on include/exclude patterns, see the :ref:`borg_patterns` command output.
-
-        For more help on placeholders, see the :ref:`borg_placeholders` command output.
-
-        .. man NOTES
-
-        The ``--exclude`` patterns are not like tar. In tar ``--exclude`` .bundler/gems will
-        exclude foo/.bundler/gems. In borg it will not, you need to use ``--exclude``
-        '\\*/.bundler/gems' to get the same effect.
-
-        In addition to using ``--exclude`` patterns, it is possible to use
-        ``--exclude-if-present`` to specify the name of a filesystem object (e.g. a file
-        or folder name) which, when contained within another folder, will prevent the
-        containing folder from being backed up.  By default, the containing folder and
-        all of its contents will be omitted from the backup.  If, however, you wish to
-        only include the objects specified by ``--exclude-if-present`` in your backup,
-        and not include any other contents of the containing folder, this can be enabled
-        through using the ``--keep-exclude-tags`` option.
-
-        The ``-x`` or ``--one-file-system`` option excludes directories, that are mountpoints (and everything in them).
-        It detects mountpoints by comparing the device number from the output of ``stat()`` of the directory and its
-        parent directory. Specifically, it excludes directories for which ``stat()`` reports a device number different
-        from the device number of their parent. Be aware that in Linux (and possibly elsewhere) there are directories
-        with device number different from their parent, which the kernel does not consider a mountpoint and also the
-        other way around. Examples are bind mounts (possibly same device number, but always a mountpoint) and ALL
-        subvolumes of a btrfs (different device number from parent but not necessarily a mountpoint). Therefore when
-        using ``--one-file-system``, one should make doubly sure that the backup works as intended especially when using
-        btrfs. This is even more important, if the btrfs layout was created by someone else, e.g. a distribution
-        installer.
-
-
-        .. _list_item_flags:
-
-        Item flags
-        ++++++++++
-
-        ``--list`` outputs a list of all files, directories and other
-        file system items it considered (no matter whether they had content changes
-        or not). For each item, it prefixes a single-letter flag that indicates type
-        and/or status of the item.
-
-        If you are interested only in a subset of that output, you can give e.g.
-        ``--filter=AME`` and it will only show regular files with A, M or E status (see
-        below).
-
-        A uppercase character represents the status of a regular file relative to the
-        "files" cache (not relative to the repo -- this is an issue if the files cache
-        is not used). Metadata is stored in any case and for 'A' and 'M' also new data
-        chunks are stored. For 'U' all data chunks refer to already existing chunks.
-
-        - 'A' = regular file, added (see also :ref:`a_status_oddity` in the FAQ)
-        - 'M' = regular file, modified
-        - 'U' = regular file, unchanged
-        - 'C' = regular file, it changed while we backed it up
-        - 'E' = regular file, an error happened while accessing/reading *this* file
-
-        A lowercase character means a file type other than a regular file,
-        borg usually just stores their metadata:
-
-        - 'd' = directory
-        - 'b' = block device
-        - 'c' = char device
-        - 'h' = regular file, hardlink (to already seen inodes)
-        - 's' = symlink
-        - 'f' = fifo
-
-        Other flags used include:
-
-        - 'i' = backup data was read from standard input (stdin)
-        - '-' = dry run, item was *not* backed up
-        - 'x' = excluded, item was *not* backed up
-        - '?' = missing status code (if you see this, please file a bug report!)
-
-        Reading from stdin
-        ++++++++++++++++++
-
-        There are two methods to read from stdin. Either specify ``-`` as path and
-        pipe directly to borg::
-
-            backup-vm --id myvm --stdout | borg create REPO::ARCHIVE -
-
-        Or use ``--content-from-command`` to have Borg manage the execution of the
-        command and piping. If you do so, the first PATH argument is interpreted
-        as command to execute and any further arguments are treated as arguments
-        to the command::
-
-            borg create --content-from-command REPO::ARCHIVE -- backup-vm --id myvm --stdout
-
-        ``--`` is used to ensure ``--id`` and ``--stdout`` are **not** considered
-        arguments to ``borg`` but rather ``backup-vm``.
-
-        The difference between the two approaches is that piping to borg creates an
-        archive even if the command piping to borg exits with a failure. In this case,
-        **one can end up with truncated output being backed up**. Using
-        ``--content-from-command``, in contrast, borg is guaranteed to fail without
-        creating an archive should the command fail. The command is considered failed
-        when it returned a non-zero exit code.
-
-        Reading from stdin yields just a stream of data without file metadata
-        associated with it, and the files cache is not needed at all. So it is
-        safe to disable it via ``--files-cache disabled`` and speed up backup
-        creation a bit.
-
-        By default, the content read from stdin is stored in a file called 'stdin'.
-        Use ``--stdin-name`` to change the name.
-        """
-        )
-
-        subparser = subparsers.add_parser(
-            "create",
-            parents=[common_parser],
-            add_help=False,
-            description=self.do_create.__doc__,
-            epilog=create_epilog,
-            formatter_class=argparse.RawDescriptionHelpFormatter,
-            help="create backup",
-        )
-        subparser.set_defaults(func=self.do_create)
-
-        # note: --dry-run and --stats are mutually exclusive, but we do not want to abort when
-        #  parsing, but rather proceed with the dry-run, but without stats (see run() method).
-        subparser.add_argument(
-            "-n", "--dry-run", dest="dry_run", action="store_true", help="do not create a backup archive"
-        )
-        subparser.add_argument(
-            "-s", "--stats", dest="stats", action="store_true", help="print statistics for the created archive"
-        )
-
-        subparser.add_argument(
-            "--list", dest="output_list", action="store_true", help="output verbose list of items (files, dirs, ...)"
-        )
-        subparser.add_argument(
-            "--filter",
-            metavar="STATUSCHARS",
-            dest="output_filter",
-            action=Highlander,
-            help="only display items with the given status characters (see description)",
-        )
-        subparser.add_argument("--json", action="store_true", help="output stats as JSON. Implies ``--stats``.")
-        subparser.add_argument(
-            "--no-cache-sync",
-            dest="no_cache_sync",
-            action="store_true",
-            help="experimental: do not synchronize the cache. Implies not using the files cache.",
-        )
-        subparser.add_argument(
-            "--stdin-name",
-            metavar="NAME",
-            dest="stdin_name",
-            default="stdin",
-            help="use NAME in archive for stdin data (default: %(default)r)",
-        )
-        subparser.add_argument(
-            "--stdin-user",
-            metavar="USER",
-            dest="stdin_user",
-            default=uid2user(0),
-            help="set user USER in archive for stdin data (default: %(default)r)",
-        )
-        subparser.add_argument(
-            "--stdin-group",
-            metavar="GROUP",
-            dest="stdin_group",
-            default=gid2group(0),
-            help="set group GROUP in archive for stdin data (default: %(default)r)",
-        )
-        subparser.add_argument(
-            "--stdin-mode",
-            metavar="M",
-            dest="stdin_mode",
-            type=lambda s: int(s, 8),
-            default=STDIN_MODE_DEFAULT,
-            help="set mode to M in archive for stdin data (default: %(default)04o)",
-        )
-        subparser.add_argument(
-            "--content-from-command",
-            action="store_true",
-            help="interpret PATH as command and store its stdout. See also section Reading from" " stdin below.",
-        )
-        subparser.add_argument(
-            "--paths-from-stdin",
-            action="store_true",
-            help="read DELIM-separated list of paths to backup from stdin. Will not " "recurse into directories.",
-        )
-        subparser.add_argument(
-            "--paths-from-command",
-            action="store_true",
-            help="interpret PATH as command and treat its output as ``--paths-from-stdin``",
-        )
-        subparser.add_argument(
-            "--paths-delimiter",
-            metavar="DELIM",
-            help="set path delimiter for ``--paths-from-stdin`` and ``--paths-from-command`` (default: \\n) ",
-        )
-
-        exclude_group = define_exclusion_group(subparser, tag_files=True)
-        exclude_group.add_argument(
-            "--exclude-nodump", dest="exclude_nodump", action="store_true", help="exclude files flagged NODUMP"
-        )
-
-        fs_group = subparser.add_argument_group("Filesystem options")
-        fs_group.add_argument(
-            "-x",
-            "--one-file-system",
-            dest="one_file_system",
-            action="store_true",
-            help="stay in the same file system and do not store mount points of other file systems.  This might behave different from your expectations, see the docs.",
-        )
-        fs_group.add_argument(
-            "--numeric-ids",
-            dest="numeric_ids",
-            action="store_true",
-            help="only store numeric user and group identifiers",
-        )
-        fs_group.add_argument("--atime", dest="atime", action="store_true", help="do store atime into archive")
-        fs_group.add_argument("--noctime", dest="noctime", action="store_true", help="do not store ctime into archive")
-        fs_group.add_argument(
-            "--nobirthtime",
-            dest="nobirthtime",
-            action="store_true",
-            help="do not store birthtime (creation date) into archive",
-        )
-        fs_group.add_argument(
-            "--noflags",
-            dest="noflags",
-            action="store_true",
-            help="do not read and store flags (e.g. NODUMP, IMMUTABLE) into archive",
-        )
-        fs_group.add_argument(
-            "--noacls", dest="noacls", action="store_true", help="do not read and store ACLs into archive"
-        )
-        fs_group.add_argument(
-            "--noxattrs", dest="noxattrs", action="store_true", help="do not read and store xattrs into archive"
-        )
-        fs_group.add_argument(
-            "--sparse",
-            dest="sparse",
-            action="store_true",
-            help="detect sparse holes in input (supported only by fixed chunker)",
-        )
-        fs_group.add_argument(
-            "--files-cache",
-            metavar="MODE",
-            dest="files_cache_mode",
-            action=Highlander,
-            type=FilesCacheMode,
-            default=FILES_CACHE_MODE_UI_DEFAULT,
-            help="operate files cache in MODE. default: %s" % FILES_CACHE_MODE_UI_DEFAULT,
-        )
-        fs_group.add_argument(
-            "--read-special",
-            dest="read_special",
-            action="store_true",
-            help="open and read block and char device files as well as FIFOs as if they were "
-            "regular files. Also follows symlinks pointing to these kinds of files.",
-        )
-
-        archive_group = subparser.add_argument_group("Archive options")
-        archive_group.add_argument(
-            "--comment",
-            dest="comment",
-            metavar="COMMENT",
-            type=CommentSpec,
-            default="",
-            help="add a comment text to the archive",
-        )
-        archive_group.add_argument(
-            "--timestamp",
-            metavar="TIMESTAMP",
-            dest="timestamp",
-            type=timestamp,
-            default=None,
-            help="manually specify the archive creation date/time (UTC, yyyy-mm-ddThh:mm:ss format). "
-            "Alternatively, give a reference file/directory.",
-        )
-        archive_group.add_argument(
-            "-c",
-            "--checkpoint-interval",
-            metavar="SECONDS",
-            dest="checkpoint_interval",
-            type=int,
-            default=1800,
-            help="write checkpoint every SECONDS seconds (Default: 1800)",
-        )
-        archive_group.add_argument(
-            "--chunker-params",
-            metavar="PARAMS",
-            dest="chunker_params",
-            type=ChunkerParams,
-            default=CHUNKER_PARAMS,
-            action=Highlander,
-            help="specify the chunker parameters (ALGO, CHUNK_MIN_EXP, CHUNK_MAX_EXP, "
-            "HASH_MASK_BITS, HASH_WINDOW_SIZE). default: %s,%d,%d,%d,%d" % CHUNKER_PARAMS,
-        )
-        archive_group.add_argument(
-            "-C",
-            "--compression",
-            metavar="COMPRESSION",
-            dest="compression",
-            type=CompressionSpec,
-            default=CompressionSpec("lz4"),
-            help="select compression algorithm, see the output of the " '"borg help compression" command for details.',
-        )
-
-        subparser.add_argument("name", metavar="NAME", type=NameSpec, help="specify the archive name")
-        subparser.add_argument("paths", metavar="PATH", nargs="*", type=str, help="paths to archive")
-
         self.build_parser_config(subparsers, common_parser, mid_common_parser)
         self.build_parser_debug(subparsers, common_parser, mid_common_parser)
         self.build_parser_delete(subparsers, common_parser, mid_common_parser)
diff --git a/src/borg/archiver/create.py b/src/borg/archiver/create.py
new file mode 100644
index 000000000..499f0f6ea
--- /dev/null
+++ b/src/borg/archiver/create.py
@@ -0,0 +1,857 @@
+import sys
+import argparse
+import logging
+import os
+import stat
+import subprocess
+import time
+from datetime import datetime
+from io import TextIOWrapper
+
+from .common import with_repository, Highlander
+from .. import helpers
+from ..archive import Archive, is_special
+from ..archive import BackupError, BackupOSError, backup_io, OsOpen, stat_update_check
+from ..archive import FilesystemObjectProcessors, MetadataCollector, ChunksProcessor
+from ..cache import Cache
+from ..constants import *  # NOQA
+from ..compress import CompressionSpec
+from ..helpers import ChunkerParams
+from ..helpers import NameSpec, CommentSpec, FilesCacheMode
+from ..helpers import eval_escapes
+from ..helpers import timestamp
+from ..helpers import get_cache_dir, os_stat
+from ..helpers import Manifest
+from ..helpers import dir_is_tagged
+from ..helpers import log_multi
+from ..helpers import basic_json_data, json_print
+from ..helpers import flags_root, flags_dir, flags_special_follow, flags_special
+from ..helpers import sig_int
+from ..helpers import iter_separated
+from ..patterns import PatternMatcher
+from ..platform import get_flags
+from ..platform import uid2user, gid2group
+
+from ..logger import create_logger
+
+logger = create_logger()
+
+
+class CreateMixIn:
+    @with_repository(fake="dry_run", exclusive=True, compatibility=(Manifest.Operation.WRITE,))
+    def do_create(self, args, repository, manifest=None, key=None):
+        """Create new archive"""
+        matcher = PatternMatcher(fallback=True)
+        matcher.add_inclexcl(args.patterns)
+
+        def create_inner(archive, cache, fso):
+            # Add cache dir to inode_skip list
+            skip_inodes = set()
+            try:
+                st = os.stat(get_cache_dir())
+                skip_inodes.add((st.st_ino, st.st_dev))
+            except OSError:
+                pass
+            # Add local repository dir to inode_skip list
+            if not args.location.host:
+                try:
+                    st = os.stat(args.location.path)
+                    skip_inodes.add((st.st_ino, st.st_dev))
+                except OSError:
+                    pass
+            logger.debug("Processing files ...")
+            if args.content_from_command:
+                path = args.stdin_name
+                mode = args.stdin_mode
+                user = args.stdin_user
+                group = args.stdin_group
+                if not dry_run:
+                    try:
+                        try:
+                            proc = subprocess.Popen(args.paths, stdout=subprocess.PIPE)
+                        except (FileNotFoundError, PermissionError) as e:
+                            self.print_error("Failed to execute command: %s", e)
+                            return self.exit_code
+                        status = fso.process_pipe(
+                            path=path, cache=cache, fd=proc.stdout, mode=mode, user=user, group=group
+                        )
+                        rc = proc.wait()
+                        if rc != 0:
+                            self.print_error("Command %r exited with status %d", args.paths[0], rc)
+                            return self.exit_code
+                    except BackupOSError as e:
+                        self.print_error("%s: %s", path, e)
+                        return self.exit_code
+                else:
+                    status = "-"
+                self.print_file_status(status, path)
+            elif args.paths_from_command or args.paths_from_stdin:
+                paths_sep = eval_escapes(args.paths_delimiter) if args.paths_delimiter is not None else "\n"
+                if args.paths_from_command:
+                    try:
+                        proc = subprocess.Popen(args.paths, stdout=subprocess.PIPE)
+                    except (FileNotFoundError, PermissionError) as e:
+                        self.print_error("Failed to execute command: %s", e)
+                        return self.exit_code
+                    pipe_bin = proc.stdout
+                else:  # args.paths_from_stdin == True
+                    pipe_bin = sys.stdin.buffer
+                pipe = TextIOWrapper(pipe_bin, errors="surrogateescape")
+                for path in iter_separated(pipe, paths_sep):
+                    path = os.path.normpath(path)
+                    try:
+                        with backup_io("stat"):
+                            st = os_stat(path=path, parent_fd=None, name=None, follow_symlinks=False)
+                        status = self._process_any(
+                            path=path,
+                            parent_fd=None,
+                            name=None,
+                            st=st,
+                            fso=fso,
+                            cache=cache,
+                            read_special=args.read_special,
+                            dry_run=dry_run,
+                        )
+                    except (BackupOSError, BackupError) as e:
+                        self.print_warning("%s: %s", path, e)
+                        status = "E"
+                    if status == "C":
+                        self.print_warning("%s: file changed while we backed it up", path)
+                    self.print_file_status(status, path)
+                if args.paths_from_command:
+                    rc = proc.wait()
+                    if rc != 0:
+                        self.print_error("Command %r exited with status %d", args.paths[0], rc)
+                        return self.exit_code
+            else:
+                for path in args.paths:
+                    if path == "-":  # stdin
+                        path = args.stdin_name
+                        mode = args.stdin_mode
+                        user = args.stdin_user
+                        group = args.stdin_group
+                        if not dry_run:
+                            try:
+                                status = fso.process_pipe(
+                                    path=path, cache=cache, fd=sys.stdin.buffer, mode=mode, user=user, group=group
+                                )
+                            except BackupOSError as e:
+                                status = "E"
+                                self.print_warning("%s: %s", path, e)
+                        else:
+                            status = "-"
+                        self.print_file_status(status, path)
+                        continue
+                    path = os.path.normpath(path)
+                    parent_dir = os.path.dirname(path) or "."
+                    name = os.path.basename(path)
+                    try:
+                        # note: for path == '/':  name == '' and parent_dir == '/'.
+                        # the empty name will trigger a fall-back to path-based processing in os_stat and os_open.
+                        with OsOpen(path=parent_dir, flags=flags_root, noatime=True, op="open_root") as parent_fd:
+                            try:
+                                st = os_stat(path=path, parent_fd=parent_fd, name=name, follow_symlinks=False)
+                            except OSError as e:
+                                self.print_warning("%s: %s", path, e)
+                                continue
+                            if args.one_file_system:
+                                restrict_dev = st.st_dev
+                            else:
+                                restrict_dev = None
+                            self._rec_walk(
+                                path=path,
+                                parent_fd=parent_fd,
+                                name=name,
+                                fso=fso,
+                                cache=cache,
+                                matcher=matcher,
+                                exclude_caches=args.exclude_caches,
+                                exclude_if_present=args.exclude_if_present,
+                                keep_exclude_tags=args.keep_exclude_tags,
+                                skip_inodes=skip_inodes,
+                                restrict_dev=restrict_dev,
+                                read_special=args.read_special,
+                                dry_run=dry_run,
+                            )
+                            # if we get back here, we've finished recursing into <path>,
+                            # we do not ever want to get back in there (even if path is given twice as recursion root)
+                            skip_inodes.add((st.st_ino, st.st_dev))
+                    except (BackupOSError, BackupError) as e:
+                        # this comes from OsOpen, self._rec_walk has own exception handler
+                        self.print_warning("%s: %s", path, e)
+                        continue
+            if not dry_run:
+                if args.progress:
+                    archive.stats.show_progress(final=True)
+                archive.stats += fso.stats
+                if sig_int:
+                    # do not save the archive if the user ctrl-c-ed - it is valid, but incomplete.
+                    # we already have a checkpoint archive in this case.
+                    self.print_error("Got Ctrl-C / SIGINT.")
+                else:
+                    archive.save(comment=args.comment, timestamp=args.timestamp, stats=archive.stats)
+                    args.stats |= args.json
+                    if args.stats:
+                        if args.json:
+                            json_print(basic_json_data(manifest, cache=cache, extra={"archive": archive}))
+                        else:
+                            log_multi(str(archive), str(archive.stats), logger=logging.getLogger("borg.output.stats"))
+
+        self.output_filter = args.output_filter
+        self.output_list = args.output_list
+        self.noflags = args.noflags
+        self.noacls = args.noacls
+        self.noxattrs = args.noxattrs
+        self.exclude_nodump = args.exclude_nodump
+        dry_run = args.dry_run
+        t0 = datetime.utcnow()
+        t0_monotonic = time.monotonic()
+        logger.info('Creating archive at "%s"' % args.location.processed)
+        if not dry_run:
+            with Cache(
+                repository,
+                key,
+                manifest,
+                progress=args.progress,
+                lock_wait=self.lock_wait,
+                permit_adhoc_cache=args.no_cache_sync,
+                cache_mode=args.files_cache_mode,
+                iec=args.iec,
+            ) as cache:
+                archive = Archive(
+                    repository,
+                    key,
+                    manifest,
+                    args.name,
+                    cache=cache,
+                    create=True,
+                    checkpoint_interval=args.checkpoint_interval,
+                    numeric_ids=args.numeric_ids,
+                    noatime=not args.atime,
+                    noctime=args.noctime,
+                    progress=args.progress,
+                    chunker_params=args.chunker_params,
+                    start=t0,
+                    start_monotonic=t0_monotonic,
+                    log_json=args.log_json,
+                    iec=args.iec,
+                )
+                metadata_collector = MetadataCollector(
+                    noatime=not args.atime,
+                    noctime=args.noctime,
+                    noflags=args.noflags,
+                    noacls=args.noacls,
+                    noxattrs=args.noxattrs,
+                    numeric_ids=args.numeric_ids,
+                    nobirthtime=args.nobirthtime,
+                )
+                cp = ChunksProcessor(
+                    cache=cache,
+                    key=key,
+                    add_item=archive.add_item,
+                    write_checkpoint=archive.write_checkpoint,
+                    checkpoint_interval=args.checkpoint_interval,
+                    rechunkify=False,
+                )
+                fso = FilesystemObjectProcessors(
+                    metadata_collector=metadata_collector,
+                    cache=cache,
+                    key=key,
+                    process_file_chunks=cp.process_file_chunks,
+                    add_item=archive.add_item,
+                    chunker_params=args.chunker_params,
+                    show_progress=args.progress,
+                    sparse=args.sparse,
+                    log_json=args.log_json,
+                    iec=args.iec,
+                    file_status_printer=self.print_file_status,
+                )
+                create_inner(archive, cache, fso)
+        else:
+            create_inner(None, None, None)
+        return self.exit_code
+
+    def _process_any(self, *, path, parent_fd, name, st, fso, cache, read_special, dry_run):
+        """
+        Call the right method on the given FilesystemObjectProcessor.
+        """
+
+        if dry_run:
+            return "-"
+        elif stat.S_ISREG(st.st_mode):
+            return fso.process_file(path=path, parent_fd=parent_fd, name=name, st=st, cache=cache)
+        elif stat.S_ISDIR(st.st_mode):
+            return fso.process_dir(path=path, parent_fd=parent_fd, name=name, st=st)
+        elif stat.S_ISLNK(st.st_mode):
+            if not read_special:
+                return fso.process_symlink(path=path, parent_fd=parent_fd, name=name, st=st)
+            else:
+                try:
+                    st_target = os_stat(path=path, parent_fd=parent_fd, name=name, follow_symlinks=True)
+                except OSError:
+                    special = False
+                else:
+                    special = is_special(st_target.st_mode)
+                if special:
+                    return fso.process_file(
+                        path=path, parent_fd=parent_fd, name=name, st=st_target, cache=cache, flags=flags_special_follow
+                    )
+                else:
+                    return fso.process_symlink(path=path, parent_fd=parent_fd, name=name, st=st)
+        elif stat.S_ISFIFO(st.st_mode):
+            if not read_special:
+                return fso.process_fifo(path=path, parent_fd=parent_fd, name=name, st=st)
+            else:
+                return fso.process_file(
+                    path=path, parent_fd=parent_fd, name=name, st=st, cache=cache, flags=flags_special
+                )
+        elif stat.S_ISCHR(st.st_mode):
+            if not read_special:
+                return fso.process_dev(path=path, parent_fd=parent_fd, name=name, st=st, dev_type="c")
+            else:
+                return fso.process_file(
+                    path=path, parent_fd=parent_fd, name=name, st=st, cache=cache, flags=flags_special
+                )
+        elif stat.S_ISBLK(st.st_mode):
+            if not read_special:
+                return fso.process_dev(path=path, parent_fd=parent_fd, name=name, st=st, dev_type="b")
+            else:
+                return fso.process_file(
+                    path=path, parent_fd=parent_fd, name=name, st=st, cache=cache, flags=flags_special
+                )
+        elif stat.S_ISSOCK(st.st_mode):
+            # Ignore unix sockets
+            return
+        elif stat.S_ISDOOR(st.st_mode):
+            # Ignore Solaris doors
+            return
+        elif stat.S_ISPORT(st.st_mode):
+            # Ignore Solaris event ports
+            return
+        else:
+            self.print_warning("Unknown file type: %s", path)
+            return
+
+    def _rec_walk(
+        self,
+        *,
+        path,
+        parent_fd,
+        name,
+        fso,
+        cache,
+        matcher,
+        exclude_caches,
+        exclude_if_present,
+        keep_exclude_tags,
+        skip_inodes,
+        restrict_dev,
+        read_special,
+        dry_run,
+    ):
+        """
+        Process *path* (or, preferably, parent_fd/name) recursively according to the various parameters.
+
+        This should only raise on critical errors. Per-item errors must be handled within this method.
+        """
+        if sig_int and sig_int.action_done():
+            # the user says "get out of here!" and we have already completed the desired action.
+            return
+
+        status = None
+        try:
+            recurse_excluded_dir = False
+            if matcher.match(path):
+                with backup_io("stat"):
+                    st = os_stat(path=path, parent_fd=parent_fd, name=name, follow_symlinks=False)
+            else:
+                self.print_file_status("x", path)
+                # get out here as quickly as possible:
+                # we only need to continue if we shall recurse into an excluded directory.
+                # if we shall not recurse, then do not even touch (stat()) the item, it
+                # could trigger an error, e.g. if access is forbidden, see #3209.
+                if not matcher.recurse_dir:
+                    return
+                recurse_excluded_dir = True
+                with backup_io("stat"):
+                    st = os_stat(path=path, parent_fd=parent_fd, name=name, follow_symlinks=False)
+                if not stat.S_ISDIR(st.st_mode):
+                    return
+
+            if (st.st_ino, st.st_dev) in skip_inodes:
+                return
+            # if restrict_dev is given, we do not want to recurse into a new filesystem,
+            # but we WILL save the mountpoint directory (or more precise: the root
+            # directory of the mounted filesystem that shadows the mountpoint dir).
+            recurse = restrict_dev is None or st.st_dev == restrict_dev
+
+            if self.exclude_nodump:
+                # Ignore if nodump flag is set
+                with backup_io("flags"):
+                    if get_flags(path=path, st=st) & stat.UF_NODUMP:
+                        self.print_file_status("x", path)
+                        return
+
+            if not stat.S_ISDIR(st.st_mode):
+                # directories cannot go in this branch because they can be excluded based on tag
+                # files they might contain
+                status = self._process_any(
+                    path=path,
+                    parent_fd=parent_fd,
+                    name=name,
+                    st=st,
+                    fso=fso,
+                    cache=cache,
+                    read_special=read_special,
+                    dry_run=dry_run,
+                )
+            else:
+                with OsOpen(
+                    path=path, parent_fd=parent_fd, name=name, flags=flags_dir, noatime=True, op="dir_open"
+                ) as child_fd:
+                    # child_fd is None for directories on windows, in that case a race condition check is not possible.
+                    if child_fd is not None:
+                        with backup_io("fstat"):
+                            st = stat_update_check(st, os.fstat(child_fd))
+                    if recurse:
+                        tag_names = dir_is_tagged(path, exclude_caches, exclude_if_present)
+                        if tag_names:
+                            # if we are already recursing in an excluded dir, we do not need to do anything else than
+                            # returning (we do not need to archive or recurse into tagged directories), see #3991:
+                            if not recurse_excluded_dir:
+                                if keep_exclude_tags:
+                                    if not dry_run:
+                                        fso.process_dir_with_fd(path=path, fd=child_fd, st=st)
+                                    for tag_name in tag_names:
+                                        tag_path = os.path.join(path, tag_name)
+                                        self._rec_walk(
+                                            path=tag_path,
+                                            parent_fd=child_fd,
+                                            name=tag_name,
+                                            fso=fso,
+                                            cache=cache,
+                                            matcher=matcher,
+                                            exclude_caches=exclude_caches,
+                                            exclude_if_present=exclude_if_present,
+                                            keep_exclude_tags=keep_exclude_tags,
+                                            skip_inodes=skip_inodes,
+                                            restrict_dev=restrict_dev,
+                                            read_special=read_special,
+                                            dry_run=dry_run,
+                                        )
+                                self.print_file_status("x", path)
+                            return
+                    if not recurse_excluded_dir and not dry_run:
+                        status = fso.process_dir_with_fd(path=path, fd=child_fd, st=st)
+                    if recurse:
+                        with backup_io("scandir"):
+                            entries = helpers.scandir_inorder(path=path, fd=child_fd)
+                        for dirent in entries:
+                            normpath = os.path.normpath(os.path.join(path, dirent.name))
+                            self._rec_walk(
+                                path=normpath,
+                                parent_fd=child_fd,
+                                name=dirent.name,
+                                fso=fso,
+                                cache=cache,
+                                matcher=matcher,
+                                exclude_caches=exclude_caches,
+                                exclude_if_present=exclude_if_present,
+                                keep_exclude_tags=keep_exclude_tags,
+                                skip_inodes=skip_inodes,
+                                restrict_dev=restrict_dev,
+                                read_special=read_special,
+                                dry_run=dry_run,
+                            )
+
+        except (BackupOSError, BackupError) as e:
+            self.print_warning("%s: %s", path, e)
+            status = "E"
+        if status == "C":
+            self.print_warning("%s: file changed while we backed it up", path)
+        if not recurse_excluded_dir:
+            self.print_file_status(status, path)
+
+    def build_parser_create(self, subparsers, common_parser, mid_common_parser):
+        from .common import process_epilog
+        from .common import define_exclusion_group
+
+        create_epilog = process_epilog(
+            """
+        This command creates a backup archive containing all files found while recursively
+        traversing all paths specified. Paths are added to the archive as they are given,
+        that means if relative paths are desired, the command has to be run from the correct
+        directory.
+
+        When giving '-' as path, borg will read data from standard input and create a
+        file 'stdin' in the created archive from that data. In some cases it's more
+        appropriate to use --content-from-command, however. See section *Reading from
+        stdin* below for details.
+
+        The archive will consume almost no disk space for files or parts of files that
+        have already been stored in other archives.
+
+        The archive name needs to be unique. It must not end in '.checkpoint' or
+        '.checkpoint.N' (with N being a number), because these names are used for
+        checkpoints and treated in special ways.
+
+        In the archive name, you may use the following placeholders:
+        {now}, {utcnow}, {fqdn}, {hostname}, {user} and some others.
+
+        Backup speed is increased by not reprocessing files that are already part of
+        existing archives and weren't modified. The detection of unmodified files is
+        done by comparing multiple file metadata values with previous values kept in
+        the files cache.
+
+        This comparison can operate in different modes as given by ``--files-cache``:
+
+        - ctime,size,inode (default)
+        - mtime,size,inode (default behaviour of borg versions older than 1.1.0rc4)
+        - ctime,size (ignore the inode number)
+        - mtime,size (ignore the inode number)
+        - rechunk,ctime (all files are considered modified - rechunk, cache ctime)
+        - rechunk,mtime (all files are considered modified - rechunk, cache mtime)
+        - disabled (disable the files cache, all files considered modified - rechunk)
+
+        inode number: better safety, but often unstable on network filesystems
+
+        Normally, detecting file modifications will take inode information into
+        consideration to improve the reliability of file change detection.
+        This is problematic for files located on sshfs and similar network file
+        systems which do not provide stable inode numbers, such files will always
+        be considered modified. You can use modes without `inode` in this case to
+        improve performance, but reliability of change detection might be reduced.
+
+        ctime vs. mtime: safety vs. speed
+
+        - ctime is a rather safe way to detect changes to a file (metadata and contents)
+          as it can not be set from userspace. But, a metadata-only change will already
+          update the ctime, so there might be some unnecessary chunking/hashing even
+          without content changes. Some filesystems do not support ctime (change time).
+          E.g. doing a chown or chmod to a file will change its ctime.
+        - mtime usually works and only updates if file contents were changed. But mtime
+          can be arbitrarily set from userspace, e.g. to set mtime back to the same value
+          it had before a content change happened. This can be used maliciously as well as
+          well-meant, but in both cases mtime based cache modes can be problematic.
+
+        The mount points of filesystems or filesystem snapshots should be the same for every
+        creation of a new archive to ensure fast operation. This is because the file cache that
+        is used to determine changed files quickly uses absolute filenames.
+        If this is not possible, consider creating a bind mount to a stable location.
+
+        The ``--progress`` option shows (from left to right) Original, Compressed and Deduplicated
+        (O, C and D, respectively), then the Number of files (N) processed so far, followed by
+        the currently processed path.
+
+        When using ``--stats``, you will get some statistics about how much data was
+        added - the "This Archive" deduplicated size there is most interesting as that is
+        how much your repository will grow. Please note that the "All archives" stats refer to
+        the state after creation. Also, the ``--stats`` and ``--dry-run`` options are mutually
+        exclusive because the data is not actually compressed and deduplicated during a dry run.
+
+        For more help on include/exclude patterns, see the :ref:`borg_patterns` command output.
+
+        For more help on placeholders, see the :ref:`borg_placeholders` command output.
+
+        .. man NOTES
+
+        The ``--exclude`` patterns are not like tar. In tar ``--exclude`` .bundler/gems will
+        exclude foo/.bundler/gems. In borg it will not, you need to use ``--exclude``
+        '\\*/.bundler/gems' to get the same effect.
+
+        In addition to using ``--exclude`` patterns, it is possible to use
+        ``--exclude-if-present`` to specify the name of a filesystem object (e.g. a file
+        or folder name) which, when contained within another folder, will prevent the
+        containing folder from being backed up.  By default, the containing folder and
+        all of its contents will be omitted from the backup.  If, however, you wish to
+        only include the objects specified by ``--exclude-if-present`` in your backup,
+        and not include any other contents of the containing folder, this can be enabled
+        through using the ``--keep-exclude-tags`` option.
+
+        The ``-x`` or ``--one-file-system`` option excludes directories, that are mountpoints (and everything in them).
+        It detects mountpoints by comparing the device number from the output of ``stat()`` of the directory and its
+        parent directory. Specifically, it excludes directories for which ``stat()`` reports a device number different
+        from the device number of their parent. Be aware that in Linux (and possibly elsewhere) there are directories
+        with device number different from their parent, which the kernel does not consider a mountpoint and also the
+        other way around. Examples are bind mounts (possibly same device number, but always a mountpoint) and ALL
+        subvolumes of a btrfs (different device number from parent but not necessarily a mountpoint). Therefore when
+        using ``--one-file-system``, one should make doubly sure that the backup works as intended especially when using
+        btrfs. This is even more important, if the btrfs layout was created by someone else, e.g. a distribution
+        installer.
+
+
+        .. _list_item_flags:
+
+        Item flags
+        ++++++++++
+
+        ``--list`` outputs a list of all files, directories and other
+        file system items it considered (no matter whether they had content changes
+        or not). For each item, it prefixes a single-letter flag that indicates type
+        and/or status of the item.
+
+        If you are interested only in a subset of that output, you can give e.g.
+        ``--filter=AME`` and it will only show regular files with A, M or E status (see
+        below).
+
+        A uppercase character represents the status of a regular file relative to the
+        "files" cache (not relative to the repo -- this is an issue if the files cache
+        is not used). Metadata is stored in any case and for 'A' and 'M' also new data
+        chunks are stored. For 'U' all data chunks refer to already existing chunks.
+
+        - 'A' = regular file, added (see also :ref:`a_status_oddity` in the FAQ)
+        - 'M' = regular file, modified
+        - 'U' = regular file, unchanged
+        - 'C' = regular file, it changed while we backed it up
+        - 'E' = regular file, an error happened while accessing/reading *this* file
+
+        A lowercase character means a file type other than a regular file,
+        borg usually just stores their metadata:
+
+        - 'd' = directory
+        - 'b' = block device
+        - 'c' = char device
+        - 'h' = regular file, hardlink (to already seen inodes)
+        - 's' = symlink
+        - 'f' = fifo
+
+        Other flags used include:
+
+        - 'i' = backup data was read from standard input (stdin)
+        - '-' = dry run, item was *not* backed up
+        - 'x' = excluded, item was *not* backed up
+        - '?' = missing status code (if you see this, please file a bug report!)
+
+        Reading from stdin
+        ++++++++++++++++++
+
+        There are two methods to read from stdin. Either specify ``-`` as path and
+        pipe directly to borg::
+
+            backup-vm --id myvm --stdout | borg create REPO::ARCHIVE -
+
+        Or use ``--content-from-command`` to have Borg manage the execution of the
+        command and piping. If you do so, the first PATH argument is interpreted
+        as command to execute and any further arguments are treated as arguments
+        to the command::
+
+            borg create --content-from-command REPO::ARCHIVE -- backup-vm --id myvm --stdout
+
+        ``--`` is used to ensure ``--id`` and ``--stdout`` are **not** considered
+        arguments to ``borg`` but rather ``backup-vm``.
+
+        The difference between the two approaches is that piping to borg creates an
+        archive even if the command piping to borg exits with a failure. In this case,
+        **one can end up with truncated output being backed up**. Using
+        ``--content-from-command``, in contrast, borg is guaranteed to fail without
+        creating an archive should the command fail. The command is considered failed
+        when it returned a non-zero exit code.
+
+        Reading from stdin yields just a stream of data without file metadata
+        associated with it, and the files cache is not needed at all. So it is
+        safe to disable it via ``--files-cache disabled`` and speed up backup
+        creation a bit.
+
+        By default, the content read from stdin is stored in a file called 'stdin'.
+        Use ``--stdin-name`` to change the name.
+        """
+        )
+
+        subparser = subparsers.add_parser(
+            "create",
+            parents=[common_parser],
+            add_help=False,
+            description=self.do_create.__doc__,
+            epilog=create_epilog,
+            formatter_class=argparse.RawDescriptionHelpFormatter,
+            help="create backup",
+        )
+        subparser.set_defaults(func=self.do_create)
+
+        # note: --dry-run and --stats are mutually exclusive, but we do not want to abort when
+        #  parsing, but rather proceed with the dry-run, but without stats (see run() method).
+        subparser.add_argument(
+            "-n", "--dry-run", dest="dry_run", action="store_true", help="do not create a backup archive"
+        )
+        subparser.add_argument(
+            "-s", "--stats", dest="stats", action="store_true", help="print statistics for the created archive"
+        )
+
+        subparser.add_argument(
+            "--list", dest="output_list", action="store_true", help="output verbose list of items (files, dirs, ...)"
+        )
+        subparser.add_argument(
+            "--filter",
+            metavar="STATUSCHARS",
+            dest="output_filter",
+            action=Highlander,
+            help="only display items with the given status characters (see description)",
+        )
+        subparser.add_argument("--json", action="store_true", help="output stats as JSON. Implies ``--stats``.")
+        subparser.add_argument(
+            "--no-cache-sync",
+            dest="no_cache_sync",
+            action="store_true",
+            help="experimental: do not synchronize the cache. Implies not using the files cache.",
+        )
+        subparser.add_argument(
+            "--stdin-name",
+            metavar="NAME",
+            dest="stdin_name",
+            default="stdin",
+            help="use NAME in archive for stdin data (default: %(default)r)",
+        )
+        subparser.add_argument(
+            "--stdin-user",
+            metavar="USER",
+            dest="stdin_user",
+            default=uid2user(0),
+            help="set user USER in archive for stdin data (default: %(default)r)",
+        )
+        subparser.add_argument(
+            "--stdin-group",
+            metavar="GROUP",
+            dest="stdin_group",
+            default=gid2group(0),
+            help="set group GROUP in archive for stdin data (default: %(default)r)",
+        )
+        subparser.add_argument(
+            "--stdin-mode",
+            metavar="M",
+            dest="stdin_mode",
+            type=lambda s: int(s, 8),
+            default=STDIN_MODE_DEFAULT,
+            help="set mode to M in archive for stdin data (default: %(default)04o)",
+        )
+        subparser.add_argument(
+            "--content-from-command",
+            action="store_true",
+            help="interpret PATH as command and store its stdout. See also section Reading from" " stdin below.",
+        )
+        subparser.add_argument(
+            "--paths-from-stdin",
+            action="store_true",
+            help="read DELIM-separated list of paths to backup from stdin. Will not " "recurse into directories.",
+        )
+        subparser.add_argument(
+            "--paths-from-command",
+            action="store_true",
+            help="interpret PATH as command and treat its output as ``--paths-from-stdin``",
+        )
+        subparser.add_argument(
+            "--paths-delimiter",
+            metavar="DELIM",
+            help="set path delimiter for ``--paths-from-stdin`` and ``--paths-from-command`` (default: \\n) ",
+        )
+
+        exclude_group = define_exclusion_group(subparser, tag_files=True)
+        exclude_group.add_argument(
+            "--exclude-nodump", dest="exclude_nodump", action="store_true", help="exclude files flagged NODUMP"
+        )
+
+        fs_group = subparser.add_argument_group("Filesystem options")
+        fs_group.add_argument(
+            "-x",
+            "--one-file-system",
+            dest="one_file_system",
+            action="store_true",
+            help="stay in the same file system and do not store mount points of other file systems.  This might behave different from your expectations, see the docs.",
+        )
+        fs_group.add_argument(
+            "--numeric-ids",
+            dest="numeric_ids",
+            action="store_true",
+            help="only store numeric user and group identifiers",
+        )
+        fs_group.add_argument("--atime", dest="atime", action="store_true", help="do store atime into archive")
+        fs_group.add_argument("--noctime", dest="noctime", action="store_true", help="do not store ctime into archive")
+        fs_group.add_argument(
+            "--nobirthtime",
+            dest="nobirthtime",
+            action="store_true",
+            help="do not store birthtime (creation date) into archive",
+        )
+        fs_group.add_argument(
+            "--noflags",
+            dest="noflags",
+            action="store_true",
+            help="do not read and store flags (e.g. NODUMP, IMMUTABLE) into archive",
+        )
+        fs_group.add_argument(
+            "--noacls", dest="noacls", action="store_true", help="do not read and store ACLs into archive"
+        )
+        fs_group.add_argument(
+            "--noxattrs", dest="noxattrs", action="store_true", help="do not read and store xattrs into archive"
+        )
+        fs_group.add_argument(
+            "--sparse",
+            dest="sparse",
+            action="store_true",
+            help="detect sparse holes in input (supported only by fixed chunker)",
+        )
+        fs_group.add_argument(
+            "--files-cache",
+            metavar="MODE",
+            dest="files_cache_mode",
+            action=Highlander,
+            type=FilesCacheMode,
+            default=FILES_CACHE_MODE_UI_DEFAULT,
+            help="operate files cache in MODE. default: %s" % FILES_CACHE_MODE_UI_DEFAULT,
+        )
+        fs_group.add_argument(
+            "--read-special",
+            dest="read_special",
+            action="store_true",
+            help="open and read block and char device files as well as FIFOs as if they were "
+            "regular files. Also follows symlinks pointing to these kinds of files.",
+        )
+
+        archive_group = subparser.add_argument_group("Archive options")
+        archive_group.add_argument(
+            "--comment",
+            dest="comment",
+            metavar="COMMENT",
+            type=CommentSpec,
+            default="",
+            help="add a comment text to the archive",
+        )
+        archive_group.add_argument(
+            "--timestamp",
+            metavar="TIMESTAMP",
+            dest="timestamp",
+            type=timestamp,
+            default=None,
+            help="manually specify the archive creation date/time (UTC, yyyy-mm-ddThh:mm:ss format). "
+            "Alternatively, give a reference file/directory.",
+        )
+        archive_group.add_argument(
+            "-c",
+            "--checkpoint-interval",
+            metavar="SECONDS",
+            dest="checkpoint_interval",
+            type=int,
+            default=1800,
+            help="write checkpoint every SECONDS seconds (Default: 1800)",
+        )
+        archive_group.add_argument(
+            "--chunker-params",
+            metavar="PARAMS",
+            dest="chunker_params",
+            type=ChunkerParams,
+            default=CHUNKER_PARAMS,
+            action=Highlander,
+            help="specify the chunker parameters (ALGO, CHUNK_MIN_EXP, CHUNK_MAX_EXP, "
+            "HASH_MASK_BITS, HASH_WINDOW_SIZE). default: %s,%d,%d,%d,%d" % CHUNKER_PARAMS,
+        )
+        archive_group.add_argument(
+            "-C",
+            "--compression",
+            metavar="COMPRESSION",
+            dest="compression",
+            type=CompressionSpec,
+            default=CompressionSpec("lz4"),
+            help="select compression algorithm, see the output of the " '"borg help compression" command for details.',
+        )
+
+        subparser.add_argument("name", metavar="NAME", type=NameSpec, help="specify the archive name")
+        subparser.add_argument("paths", metavar="PATH", nargs="*", type=str, help="paths to archive")

From b2fb334af09cc61f17720841c9f75991e00f3fce Mon Sep 17 00:00:00 2001
From: Thomas Waldmann <tw@waldmann-edv.de>
Date: Sat, 9 Jul 2022 03:18:51 +0200
Subject: [PATCH 145/160] sort build_parser calls / mixins

---
 src/borg/archiver/__init__.py | 34 +++++++++++++++-------------------
 src/borg/archiver/rdelete.py  |  2 +-
 2 files changed, 16 insertions(+), 20 deletions(-)

diff --git a/src/borg/archiver/__init__.py b/src/borg/archiver/__init__.py
index 701acbe37..a160f1ab1 100644
--- a/src/borg/archiver/__init__.py
+++ b/src/borg/archiver/__init__.py
@@ -90,30 +90,30 @@ from .transfer import TransferMixIn
 
 
 class Archiver(
+    BenchmarkMixIn,
     CheckMixIn,
-    ConfigMixIn,
     CompactMixIn,
+    ConfigMixIn,
     CreateMixIn,
     DebugMixIn,
     DeleteMixIn,
     DiffMixIn,
     ExtractMixIn,
-    TarMixIn,
-    BenchmarkMixIn,
+    HelpMixIn,
+    InfoMixIn,
     KeysMixIn,
     ListMixIn,
     LocksMixIn,
     MountMixIn,
     PruneMixIn,
-    HelpMixIn,
-    InfoMixIn,
     RecreateMixIn,
     RenameMixIn,
     RCreateMixIn,
-    RInfoMixIn,
     RDeleteMixIn,
+    RInfoMixIn,
     RListMixIn,
     ServeMixIn,
+    TarMixIn,
     TransferMixIn,
 ):
     def __init__(self, lock_wait=None, prog=None):
@@ -450,32 +450,28 @@ class Archiver(
         self.build_parser_benchmarks(subparsers, common_parser, mid_common_parser)
         self.build_parser_check(subparsers, common_parser, mid_common_parser)
         self.build_parser_compact(subparsers, common_parser, mid_common_parser)
+        self.build_parser_config(subparsers, common_parser, mid_common_parser)
         self.build_parser_create(subparsers, common_parser, mid_common_parser)
+        self.build_parser_debug(subparsers, common_parser, mid_common_parser)
+        self.build_parser_delete(subparsers, common_parser, mid_common_parser)
         self.build_parser_diff(subparsers, common_parser, mid_common_parser)
+        self.build_parser_extract(subparsers, common_parser, mid_common_parser)
+        self.build_parser_help(subparsers, common_parser, mid_common_parser, parser)
+        self.build_parser_info(subparsers, common_parser, mid_common_parser)
+        self.build_parser_keys(subparsers, common_parser, mid_common_parser)
         self.build_parser_list(subparsers, common_parser, mid_common_parser)
         self.build_parser_locks(subparsers, common_parser, mid_common_parser)
         self.build_parser_mount_umount(subparsers, common_parser, mid_common_parser)
         self.build_parser_prune(subparsers, common_parser, mid_common_parser)
-
-        self.build_parser_config(subparsers, common_parser, mid_common_parser)
-        self.build_parser_debug(subparsers, common_parser, mid_common_parser)
-        self.build_parser_delete(subparsers, common_parser, mid_common_parser)
-        self.build_parser_extract(subparsers, common_parser, mid_common_parser)
-        self.build_parser_help(subparsers, common_parser, mid_common_parser, parser)
-        self.build_parser_rdelete(subparsers, common_parser, mid_common_parser, parser)
+        self.build_parser_rcreate(subparsers, common_parser, mid_common_parser)
+        self.build_parser_rdelete(subparsers, common_parser, mid_common_parser)
         self.build_parser_rinfo(subparsers, common_parser, mid_common_parser)
         self.build_parser_rlist(subparsers, common_parser, mid_common_parser)
-        self.build_parser_info(subparsers, common_parser, mid_common_parser)
-        self.build_parser_keys(subparsers, common_parser, mid_common_parser)
-        self.build_parser_rcreate(subparsers, common_parser, mid_common_parser)
-
         self.build_parser_recreate(subparsers, common_parser, mid_common_parser)
         self.build_parser_rename(subparsers, common_parser, mid_common_parser)
         self.build_parser_serve(subparsers, common_parser, mid_common_parser)
         self.build_parser_tar(subparsers, common_parser, mid_common_parser)
-
         self.build_parser_transfer(subparsers, common_parser, mid_common_parser)
-
         return parser
 
     def get_args(self, argv, cmd):
diff --git a/src/borg/archiver/rdelete.py b/src/borg/archiver/rdelete.py
index 8a1a4e150..4f6a0d2a3 100644
--- a/src/borg/archiver/rdelete.py
+++ b/src/borg/archiver/rdelete.py
@@ -90,7 +90,7 @@ class RDeleteMixIn:
             logger.info("Would delete cache.")
         return self.exit_code
 
-    def build_parser_rdelete(self, subparsers, common_parser, mid_common_parser, parser):
+    def build_parser_rdelete(self, subparsers, common_parser, mid_common_parser):
 
         from .common import process_epilog
 

From ea6b373f85a7fc9bfbece2dc789b05a7b362de77 Mon Sep 17 00:00:00 2001
From: Thomas Waldmann <tw@waldmann-edv.de>
Date: Sat, 9 Jul 2022 03:34:19 +0200
Subject: [PATCH 146/160] move common options definition to archiver.common

---
 src/borg/archiver/__init__.py | 141 +---------------------------------
 src/borg/archiver/common.py   | 139 ++++++++++++++++++++++++++++++++-
 2 files changed, 139 insertions(+), 141 deletions(-)

diff --git a/src/borg/archiver/__init__.py b/src/borg/archiver/__init__.py
index a160f1ab1..2034589fd 100644
--- a/src/borg/archiver/__init__.py
+++ b/src/borg/archiver/__init__.py
@@ -24,7 +24,6 @@ try:
     from ..constants import *  # NOQA
     from ..helpers import EXIT_SUCCESS, EXIT_WARNING, EXIT_ERROR, EXIT_SIGNAL_BASE
     from ..helpers import Error, set_ec
-    from ..helpers import location_validator, Location
     from ..helpers import format_file_size
     from ..helpers import remove_surrogates
     from ..helpers import check_python, check_extension_modules
@@ -283,145 +282,7 @@ class Archiver(
                 setattr(args, dest, option_value)
 
     def build_parser(self):
-        def define_common_options(add_common_option):
-            add_common_option("-h", "--help", action="help", help="show this help message and exit")
-            add_common_option(
-                "--critical",
-                dest="log_level",
-                action="store_const",
-                const="critical",
-                default="warning",
-                help="work on log level CRITICAL",
-            )
-            add_common_option(
-                "--error",
-                dest="log_level",
-                action="store_const",
-                const="error",
-                default="warning",
-                help="work on log level ERROR",
-            )
-            add_common_option(
-                "--warning",
-                dest="log_level",
-                action="store_const",
-                const="warning",
-                default="warning",
-                help="work on log level WARNING (default)",
-            )
-            add_common_option(
-                "--info",
-                "-v",
-                "--verbose",
-                dest="log_level",
-                action="store_const",
-                const="info",
-                default="warning",
-                help="work on log level INFO",
-            )
-            add_common_option(
-                "--debug",
-                dest="log_level",
-                action="store_const",
-                const="debug",
-                default="warning",
-                help="enable debug output, work on log level DEBUG",
-            )
-            add_common_option(
-                "--debug-topic",
-                metavar="TOPIC",
-                dest="debug_topics",
-                action="append",
-                default=[],
-                help="enable TOPIC debugging (can be specified multiple times). "
-                "The logger path is borg.debug.<TOPIC> if TOPIC is not fully qualified.",
-            )
-            add_common_option(
-                "-p", "--progress", dest="progress", action="store_true", help="show progress information"
-            )
-            add_common_option("--iec", dest="iec", action="store_true", help="format using IEC units (1KiB = 1024B)")
-            add_common_option(
-                "--log-json",
-                dest="log_json",
-                action="store_true",
-                help="Output one JSON object per log line instead of formatted text.",
-            )
-            add_common_option(
-                "--lock-wait",
-                metavar="SECONDS",
-                dest="lock_wait",
-                type=int,
-                default=1,
-                help="wait at most SECONDS for acquiring a repository/cache lock (default: %(default)d).",
-            )
-            add_common_option(
-                "--bypass-lock",
-                dest="lock",
-                action="store_false",
-                default=argparse.SUPPRESS,  # only create args attribute if option is specified
-                help="Bypass locking mechanism",
-            )
-            add_common_option(
-                "--show-version", dest="show_version", action="store_true", help="show/log the borg version"
-            )
-            add_common_option("--show-rc", dest="show_rc", action="store_true", help="show/log the return code (rc)")
-            add_common_option(
-                "--umask",
-                metavar="M",
-                dest="umask",
-                type=lambda s: int(s, 8),
-                default=UMASK_DEFAULT,
-                help="set umask to M (local only, default: %(default)04o)",
-            )
-            add_common_option(
-                "--remote-path",
-                metavar="PATH",
-                dest="remote_path",
-                help='use PATH as borg executable on the remote (default: "borg")',
-            )
-            add_common_option(
-                "--upload-ratelimit",
-                metavar="RATE",
-                dest="upload_ratelimit",
-                type=int,
-                help="set network upload rate limit in kiByte/s (default: 0=unlimited)",
-            )
-            add_common_option(
-                "--upload-buffer",
-                metavar="UPLOAD_BUFFER",
-                dest="upload_buffer",
-                type=int,
-                help="set network upload buffer size in MiB. (default: 0=no buffer)",
-            )
-            add_common_option(
-                "--consider-part-files",
-                dest="consider_part_files",
-                action="store_true",
-                help="treat part files like normal files (e.g. to list/extract them)",
-            )
-            add_common_option(
-                "--debug-profile",
-                metavar="FILE",
-                dest="debug_profile",
-                default=None,
-                help="Write execution profile in Borg format into FILE. For local use a Python-"
-                'compatible file can be generated by suffixing FILE with ".pyprof".',
-            )
-            add_common_option(
-                "--rsh",
-                metavar="RSH",
-                dest="rsh",
-                help="Use this command to connect to the 'borg serve' process (default: 'ssh')",
-            )
-            add_common_option(
-                "-r",
-                "--repo",
-                metavar="REPO",
-                dest="location",
-                type=location_validator(other=False),
-                default=Location(other=False),
-                help="repository to use",
-            )
+        from .common import define_common_options
 
         parser = argparse.ArgumentParser(prog=self.prog, description="Borg - Deduplicated Backups", add_help=False)
         # paths and patterns must have an empty list as default everywhere
diff --git a/src/borg/archiver/common.py b/src/borg/archiver/common.py
index 285832295..c47138610 100644
--- a/src/borg/archiver/common.py
+++ b/src/borg/archiver/common.py
@@ -9,7 +9,7 @@ from ..constants import *  # NOQA
 from ..cache import Cache, assert_secure
 from ..helpers import Error
 from ..helpers import Manifest, AI_HUMAN_SORT_KEYS
-from ..helpers import GlobSpec, SortBySpec, positive_int_validator
+from ..helpers import GlobSpec, SortBySpec, positive_int_validator, location_validator, Location
 from ..patterns import PatternMatcher
 from ..remote import RemoteRepository
 from ..repository import Repository
@@ -424,6 +424,143 @@ def define_archive_filters_group(subparser, *, sort_by=True, first_last=True):
     return filters_group
 
 
+def define_common_options(add_common_option):
+    add_common_option("-h", "--help", action="help", help="show this help message and exit")
+    add_common_option(
+        "--critical",
+        dest="log_level",
+        action="store_const",
+        const="critical",
+        default="warning",
+        help="work on log level CRITICAL",
+    )
+    add_common_option(
+        "--error",
+        dest="log_level",
+        action="store_const",
+        const="error",
+        default="warning",
+        help="work on log level ERROR",
+    )
+    add_common_option(
+        "--warning",
+        dest="log_level",
+        action="store_const",
+        const="warning",
+        default="warning",
+        help="work on log level WARNING (default)",
+    )
+    add_common_option(
+        "--info",
+        "-v",
+        "--verbose",
+        dest="log_level",
+        action="store_const",
+        const="info",
+        default="warning",
+        help="work on log level INFO",
+    )
+    add_common_option(
+        "--debug",
+        dest="log_level",
+        action="store_const",
+        const="debug",
+        default="warning",
+        help="enable debug output, work on log level DEBUG",
+    )
+    add_common_option(
+        "--debug-topic",
+        metavar="TOPIC",
+        dest="debug_topics",
+        action="append",
+        default=[],
+        help="enable TOPIC debugging (can be specified multiple times). "
+        "The logger path is borg.debug.<TOPIC> if TOPIC is not fully qualified.",
+    )
+    add_common_option("-p", "--progress", dest="progress", action="store_true", help="show progress information")
+    add_common_option("--iec", dest="iec", action="store_true", help="format using IEC units (1KiB = 1024B)")
+    add_common_option(
+        "--log-json",
+        dest="log_json",
+        action="store_true",
+        help="Output one JSON object per log line instead of formatted text.",
+    )
+    add_common_option(
+        "--lock-wait",
+        metavar="SECONDS",
+        dest="lock_wait",
+        type=int,
+        default=1,
+        help="wait at most SECONDS for acquiring a repository/cache lock (default: %(default)d).",
+    )
+    add_common_option(
+        "--bypass-lock",
+        dest="lock",
+        action="store_false",
+        default=argparse.SUPPRESS,  # only create args attribute if option is specified
+        help="Bypass locking mechanism",
+    )
+    add_common_option("--show-version", dest="show_version", action="store_true", help="show/log the borg version")
+    add_common_option("--show-rc", dest="show_rc", action="store_true", help="show/log the return code (rc)")
+    add_common_option(
+        "--umask",
+        metavar="M",
+        dest="umask",
+        type=lambda s: int(s, 8),
+        default=UMASK_DEFAULT,
+        help="set umask to M (local only, default: %(default)04o)",
+    )
+    add_common_option(
+        "--remote-path",
+        metavar="PATH",
+        dest="remote_path",
+        help='use PATH as borg executable on the remote (default: "borg")',
+    )
+    add_common_option(
+        "--upload-ratelimit",
+        metavar="RATE",
+        dest="upload_ratelimit",
+        type=int,
+        help="set network upload rate limit in kiByte/s (default: 0=unlimited)",
+    )
+    add_common_option(
+        "--upload-buffer",
+        metavar="UPLOAD_BUFFER",
+        dest="upload_buffer",
+        type=int,
+        help="set network upload buffer size in MiB. (default: 0=no buffer)",
+    )
+    add_common_option(
+        "--consider-part-files",
+        dest="consider_part_files",
+        action="store_true",
+        help="treat part files like normal files (e.g. to list/extract them)",
+    )
+    add_common_option(
+        "--debug-profile",
+        metavar="FILE",
+        dest="debug_profile",
+        default=None,
+        help="Write execution profile in Borg format into FILE. For local use a Python-"
+        'compatible file can be generated by suffixing FILE with ".pyprof".',
+    )
+    add_common_option(
+        "--rsh",
+        metavar="RSH",
+        dest="rsh",
+        help="Use this command to connect to the 'borg serve' process (default: 'ssh')",
+    )
+    add_common_option(
+        "-r",
+        "--repo",
+        metavar="REPO",
+        dest="location",
+        type=location_validator(other=False),
+        default=Location(other=False),
+        help="repository to use",
+    )
+
+
 def build_matcher(inclexcl_patterns, include_paths):
     matcher = PatternMatcher()
     matcher.add_inclexcl(inclexcl_patterns)

From 55a5c5867a766a9bbd11df4b8d0a1a05a44b1b7a Mon Sep 17 00:00:00 2001
From: Thomas Waldmann <tw@waldmann-edv.de>
Date: Sat, 9 Jul 2022 15:34:15 +0200
Subject: [PATCH 147/160] update CHANGES

---
 docs/changes.rst | 19 ++++++++++++++++++-
 1 file changed, 18 insertions(+), 1 deletion(-)

diff --git a/docs/changes.rst b/docs/changes.rst
index 2a33bdada..d9e40e4cd 100644
--- a/docs/changes.rst
+++ b/docs/changes.rst
@@ -12,7 +12,7 @@ This section provides information about security and corruption issues.
 Change Log 2.x
 ==============
 
-Version 2.0.0a3 (2022-07-04)
+Version 2.0.0a4 (2022-07-xx)
 ----------------------------
 
 Please note:
@@ -78,6 +78,23 @@ Compatibility notes:
   - removed --nobsdflags (use --noflags)
   - removed --noatime (default now, see also --atime)
 
+
+New features:
+
+- recreate: consider level for recompression, #6698, #3622
+
+Other changes:
+
+- stop using libdeflate
+- split up archiver module, transform it into a package
+- use Black for automated code formatting
+- use language_level = 3str for cython (this will be the default in cython 3)
+- docs: document HardLinkManager and hlid, #2388
+
+
+Version 2.0.0a3 (2022-07-04)
+----------------------------
+
 Fixes:
 
 - check repo version, accept old repos only for --other-repo (e.g. rcreate/transfer).

From 1de12eacb781327bb72d352002cff9a8cbd4a249 Mon Sep 17 00:00:00 2001
From: Thomas Waldmann <tw@waldmann-edv.de>
Date: Wed, 13 Jul 2022 16:42:46 +0200
Subject: [PATCH 148/160] we remove scp style, also remove it for tilde
 expansion, fixes #6856

---
 src/borg/remote.py | 5 -----
 1 file changed, 5 deletions(-)

diff --git a/src/borg/remote.py b/src/borg/remote.py
index f3b7ef6f0..093a3e7f3 100644
--- a/src/borg/remote.py
+++ b/src/borg/remote.py
@@ -332,15 +332,10 @@ class RepositoryServer:  # pragma: no cover
     def _resolve_path(self, path):
         if isinstance(path, bytes):
             path = os.fsdecode(path)
-        # Leading slash is always present with URI (ssh://), but not with short-form (who@host:path).
         if path.startswith("/~/"):  # /~/x = path x relative to home dir
             path = os.path.join(get_base_dir(), path[3:])
-        elif path.startswith("~/"):
-            path = os.path.join(get_base_dir(), path[2:])
         elif path.startswith("/~"):  # /~username/x = relative to "user" home dir
             path = os.path.expanduser(path[1:])
-        elif path.startswith("~"):
-            path = os.path.expanduser(path)
         elif path.startswith("/./"):  # /./x = path x relative to cwd
             path = path[3:]
         return os.path.realpath(path)

From 7bc7f013427edeff45b3f051b7ac0bd47563975c Mon Sep 17 00:00:00 2001
From: Thomas Waldmann <tw@waldmann-edv.de>
Date: Wed, 13 Jul 2022 16:55:29 +0200
Subject: [PATCH 149/160] remove remainders of attic legacy

we expect that everybody has upgraded to borg
using borg 1.2.x or older, thus we do not need
to care about attic repos any more in borg2.
---
 src/borg/archive.py           |  2 +-
 src/borg/archiver/recreate.py |  3 +--
 src/borg/constants.py         |  2 +-
 src/borg/remote.py            |  5 -----
 src/borg/repository.py        | 13 -------------
 src/borg/testsuite/crypto.py  |  2 +-
 src/borg/upgrade.py           |  2 +-
 7 files changed, 5 insertions(+), 24 deletions(-)

diff --git a/src/borg/archive.py b/src/borg/archive.py
index d346a425f..f6a7a900d 100644
--- a/src/borg/archive.py
+++ b/src/borg/archive.py
@@ -1080,7 +1080,7 @@ class MetadataCollector:
 
     def stat_simple_attrs(self, st):
         attrs = dict(mode=st.st_mode, uid=st.st_uid, gid=st.st_gid, mtime=safe_ns(st.st_mtime_ns))
-        # borg can work with archives only having mtime (older attic archives do not have
+        # borg can work with archives only having mtime (very old borg archives do not have
         # atime/ctime). it can be useful to omit atime/ctime, if they change without the
         # file content changing - e.g. to get better metadata deduplication.
         if not self.noatime:
diff --git a/src/borg/archiver/recreate.py b/src/borg/archiver/recreate.py
index 0aef1d29b..3a0a64dbd 100644
--- a/src/borg/archiver/recreate.py
+++ b/src/borg/archiver/recreate.py
@@ -89,8 +89,7 @@ class RecreateMixIn:
         There is no risk of data loss by this.
 
         ``--chunker-params`` will re-chunk all files in the archive, this can be
-        used to have upgraded Borg 0.xx or Attic archives deduplicate with
-        Borg 1.x archives.
+        used to have upgraded Borg 0.xx archives deduplicate with Borg 1.x archives.
 
         **USE WITH CAUTION.**
         Depending on the PATHs and patterns given, recreate can be used to permanently
diff --git a/src/borg/constants.py b/src/borg/constants.py
index a7406a63f..b5a001518 100644
--- a/src/borg/constants.py
+++ b/src/borg/constants.py
@@ -135,7 +135,7 @@ class KeyType:
     # in borg 2. all of its code and also the "borg key migrate-to-repokey" command was removed.
     # if you still need to, you can use "borg key migrate-to-repokey" with borg 1.0, 1.1 and 1.2.
     # Nowadays, we just dispatch this to RepoKey and assume the passphrase was migrated to a repokey.
-    PASSPHRASE = 0x01  # legacy, attic and borg < 1.0
+    PASSPHRASE = 0x01  # legacy, borg < 1.0
     PLAINTEXT = 0x02
     REPO = 0x03
     BLAKE2KEYFILE = 0x04
diff --git a/src/borg/remote.py b/src/borg/remote.py
index f3b7ef6f0..d841109e1 100644
--- a/src/borg/remote.py
+++ b/src/borg/remote.py
@@ -791,11 +791,6 @@ This problem will go away as soon as the server has been upgraded to 1.0.7+.
                     raise IntegrityError("(not available)")
                 else:
                     raise IntegrityError(args[0])
-            elif error == "AtticRepository":
-                if old_server:
-                    raise Repository.AtticRepository("(not available)")
-                else:
-                    raise Repository.AtticRepository(args[0])
             elif error == "PathNotAllowed":
                 if old_server:
                     raise PathNotAllowed("(unknown)")
diff --git a/src/borg/repository.py b/src/borg/repository.py
index 3a05b09ef..38a1b93ac 100644
--- a/src/borg/repository.py
+++ b/src/borg/repository.py
@@ -32,8 +32,6 @@ logger = create_logger(__name__)
 
 MAGIC = b"BORG_SEG"
 MAGIC_LEN = len(MAGIC)
-ATTIC_MAGIC = b"ATTICSEG"
-assert len(ATTIC_MAGIC) == MAGIC_LEN
 
 TAG_PUT = 0
 TAG_DELETE = 1
@@ -152,9 +150,6 @@ class Repository:
     class InvalidRepositoryConfig(Error):
         """{} does not have a valid configuration. Check repo config [{}]."""
 
-    class AtticRepository(Error):
-        """Attic repository detected. Please use borg <= 1.2 to run "borg upgrade {}"."""
-
     class CheckNeeded(ErrorWithTraceback):
         """Inconsistency detected. Please run "borg check {}"."""
 
@@ -181,7 +176,6 @@ class Repository:
         lock=True,
         append_only=False,
         storage_quota=None,
-        check_segment_magic=True,
         make_parent_dirs=False,
     ):
         self.path = os.path.abspath(path)
@@ -205,7 +199,6 @@ class Repository:
         self.storage_quota = storage_quota
         self.storage_quota_use = 0
         self.transaction_doomed = None
-        self.check_segment_magic = check_segment_magic
         self.make_parent_dirs = make_parent_dirs
         # v2 is the default repo version for borg 2.0
         # v1 repos must only be used in a read-only way, e.g. for
@@ -498,12 +491,6 @@ class Repository:
             self.storage_quota = parse_file_size(self.config.get("repository", "storage_quota", fallback=0))
         self.id = unhexlify(self.config.get("repository", "id").strip())
         self.io = LoggedIO(self.path, self.max_segment_size, self.segments_per_dir)
-        if self.check_segment_magic:
-            # read a segment and check whether we are dealing with a non-upgraded Attic repository
-            segment = self.io.get_latest_segment()
-            if segment is not None and self.io.get_segment_magic(segment) == ATTIC_MAGIC:
-                self.close()
-                raise self.AtticRepository(path)
 
     def info(self):
         """return some infos about the repo (must be opened first)"""
diff --git a/src/borg/testsuite/crypto.py b/src/borg/testsuite/crypto.py
index 78a6c8949..6ab7be026 100644
--- a/src/borg/testsuite/crypto.py
+++ b/src/borg/testsuite/crypto.py
@@ -34,7 +34,7 @@ class CryptoTestCase(BaseTestCase):
         self.assert_equal(got_data, data)
 
     def test_AES256_CTR_HMAC_SHA256(self):
-        # this tests the layout as in attic / borg < 1.2 (1 type byte, no aad)
+        # this tests the layout as in borg < 1.2 (1 type byte, no aad)
         mac_key = b"Y" * 32
         enc_key = b"X" * 32
         iv = 0
diff --git a/src/borg/upgrade.py b/src/borg/upgrade.py
index 329fa7983..68ba59f27 100644
--- a/src/borg/upgrade.py
+++ b/src/borg/upgrade.py
@@ -102,7 +102,7 @@ class UpgraderFrom12To20:
         def upgrade_zlib_and_level(chunk):
             if ZLIB_legacy.detect(chunk):
                 ctype = ZLIB.ID
-                chunk = ctype + level + bytes(chunk)  # get rid of the attic legacy: prepend separate type/level bytes
+                chunk = ctype + level + bytes(chunk)  # get rid of the legacy: prepend separate type/level bytes
             else:
                 ctype = bytes(chunk[0:1])
                 chunk = ctype + level + bytes(chunk[2:])  # keep type same, but set level

From 2d2f468410811a6aef997466233a4e550b04e54f Mon Sep 17 00:00:00 2001
From: Thomas Waldmann <tw@waldmann-edv.de>
Date: Wed, 13 Jul 2022 17:06:52 +0200
Subject: [PATCH 150/160] remove legacy_cleanup

not needed any more.
---
 src/borg/cache.py | 16 ----------------
 1 file changed, 16 deletions(-)

diff --git a/src/borg/cache.py b/src/borg/cache.py
index a6148c66d..5c5d5e33e 100644
--- a/src/borg/cache.py
+++ b/src/borg/cache.py
@@ -898,21 +898,6 @@ class LocalCache(CacheStatsMixin):
             logger.info("Done.")
             return chunk_idx
 
-        def legacy_cleanup():
-            """bring old cache dirs into the desired state (cleanup and adapt)"""
-            try:
-                os.unlink(os.path.join(self.path, "chunks.archive"))
-            except:
-                pass
-            try:
-                os.unlink(os.path.join(self.path, "chunks.archive.tmp"))
-            except:
-                pass
-            try:
-                os.mkdir(archive_path)
-            except:
-                pass
-
         # The cache can be used by a command that e.g. only checks against Manifest.Operation.WRITE,
         # which does not have to include all flags from Manifest.Operation.READ.
         # Since the sync will attempt to read archives, check compatibility with Manifest.Operation.READ.
@@ -920,7 +905,6 @@ class LocalCache(CacheStatsMixin):
 
         self.begin_txn()
         with cache_if_remote(self.repository, decrypted_cache=self.key) as decrypted_repository:
-            legacy_cleanup()
             # TEMPORARY HACK: to avoid archive index caching, create a FILE named ~/.cache/borg/REPOID/chunks.archive.d -
             # this is only recommended if you have a fast, low latency connection to your repo (e.g. if repo is local disk)
             self.do_cache = os.path.isdir(archive_path)

From b07aeef4981c936eba63e5e1b5534838234c9fde Mon Sep 17 00:00:00 2001
From: Thomas Waldmann <tw@waldmann-edv.de>
Date: Fri, 15 Jul 2022 12:44:56 +0200
Subject: [PATCH 151/160] add mypy checking

also added some .pyi files needed to check the cython code (taken from #5703 and updated).

fixed "syntax error" in key.py.

all mypy complaints not fixed yet.
---
 .github/workflows/ci.yml |   7 +-
 setup.cfg                |  20 +++
 src/borg/checksums.pyi   |   8 +
 src/borg/chunker.pyi     |  28 ++++
 src/borg/compress.pyi    |  63 ++++++++
 src/borg/crypto/key.py   |   2 +-
 src/borg/hashindex.pyi   |  88 +++++++++++
 src/borg/item.pyi        | 305 +++++++++++++++++++++++++++++++++++++++
 tox.ini                  |   8 +
 9 files changed, 526 insertions(+), 3 deletions(-)
 create mode 100644 src/borg/checksums.pyi
 create mode 100644 src/borg/chunker.pyi
 create mode 100644 src/borg/compress.pyi
 create mode 100644 src/borg/hashindex.pyi
 create mode 100644 src/borg/item.pyi

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 8ef2e8f65..cf6183276 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -45,12 +45,15 @@ jobs:
         pip install flake8
         flake8 src scripts conftest.py
 
-  pytest:
+  tox:
 
     needs: lint
     strategy:
       matrix:
         include:
+            - os: ubuntu-20.04
+              python-version: '3.9'
+              toxenv: mypy
             - os: ubuntu-20.04
               python-version: '3.9'
               toxenv: py39-fuse2
@@ -117,7 +120,7 @@ jobs:
       run: |
         # pip install -e .
         python setup.py -v develop
-    - name: run pytest via tox
+    - name: run tox env
       run: |
         # do not use fakeroot, but run as root. avoids the dreaded EISDIR sporadic failures. see #2482.
         #sudo -E bash -c "tox -e py"
diff --git a/setup.cfg b/setup.cfg
index 2763d4434..a4f2d8e4b 100644
--- a/setup.cfg
+++ b/setup.cfg
@@ -177,3 +177,23 @@ per_file_ignores =
 max_line_length = 120
 exclude = build,dist,.git,.idea,.cache,.tox
 
+[mypy]
+python_version = 3.9
+strict_optional = False
+local_partial_types = True
+show_error_codes = True
+files = src/borg/**/*.py
+
+[mypy-msgpack.*]
+ignore_missing_imports = True
+[mypy-llfuse]
+ignore_missing_imports = True
+[mypy-pyfuse3]
+ignore_missing_imports = True
+[mypy-trio]
+ignore_missing_imports = True
+
+[mypy-borg.crypto.low_level]
+ignore_missing_imports = True
+[mypy-borg.platform.*]
+ignore_missing_imports = True
diff --git a/src/borg/checksums.pyi b/src/borg/checksums.pyi
new file mode 100644
index 000000000..adbb10578
--- /dev/null
+++ b/src/borg/checksums.pyi
@@ -0,0 +1,8 @@
+def crc32(data: bytes, value: int = 0) -> int: ...
+def xxh64(data: bytes, seed: int = 0) -> bytes: ...
+
+class StreamingXXH64:
+    def __init__(self, seed: int = 0) -> None: ...
+    def update(self, data: bytes) -> None: ...
+    def digest(self) -> bytes: ...
+    def hexdigest(self) -> str: ...
diff --git a/src/borg/chunker.pyi b/src/borg/chunker.pyi
new file mode 100644
index 000000000..0d2e493f6
--- /dev/null
+++ b/src/borg/chunker.pyi
@@ -0,0 +1,28 @@
+from typing import NamedTuple, Tuple, List, Dict, Any, Type, Iterator, BinaryIO
+
+API_VERSION: str
+
+has_seek_hole: bool
+
+class _Chunk(NamedTuple):
+    data: bytes
+    meta: Dict[str, Any]
+
+def Chunk(data: bytes, **meta) -> Type[_Chunk]: ...
+def buzhash(data: bytes, seed: int) -> int: ...
+def buzhash_update(sum: int, remove: int, add: int, len: int, seed: int) -> int: ...
+def get_chunker(algo: str, *params, **kw) -> Any: ...
+
+fmap_entry = Tuple[int, int, bool]
+
+def sparsemap(fd: BinaryIO = None, fh: int = -1) -> List[fmap_entry]: ...
+
+class ChunkerFixed:
+    def __init__(self, block_size: int, header_size: int = 0, sparse: bool = False) -> None: ...
+    def chunkify(self, fd: BinaryIO = None, fh: int = -1, fmap: List[fmap_entry] = None) -> Iterator: ...
+
+class Chunker:
+    def __init__(
+        self, seed: int, chunk_min_exp: int, chunk_max_exp: int, hash_mask_bits: int, hash_window_size: int
+    ) -> None: ...
+    def chunkify(self, fd: BinaryIO = None, fh: int = -1) -> Iterator: ...
diff --git a/src/borg/compress.pyi b/src/borg/compress.pyi
new file mode 100644
index 000000000..34569f27a
--- /dev/null
+++ b/src/borg/compress.pyi
@@ -0,0 +1,63 @@
+from typing import Any, Type
+
+API_VERSION: str
+
+def get_compressor(name: str, **kwargs) -> Any: ...
+
+class CompressionSpec:
+    def __init__(self, spec: str) -> None: ...
+    @property
+    def compressor(self) -> Any: ...
+    inner: CompressionSpec
+
+class Compressor:
+    def __init__(self, name: Any = ..., **kwargs) -> None: ...
+    def compress(self, data: bytes) -> bytes: ...
+    def decompress(self, data: bytes) -> bytes: ...
+    @staticmethod
+    def detect(data: bytes) -> Any: ...
+
+class CompressorBase:
+    ID: bytes = ...
+    name: str = ...
+    @classmethod
+    def detect(self, data: bytes) -> bool: ...
+    def __init__(self, level: int = ..., **kwargs) -> None: ...
+    def decide(self, data: bytes) -> Any: ...
+    def compress(self, data: bytes) -> bytes: ...
+    def decompress(self, data: bytes) -> bytes: ...
+
+class Auto(CompressorBase):
+    def __init__(self, compressor: Any) -> None: ...
+
+class DecidingCompressor(CompressorBase):
+    def __init__(self, level: int = ..., **kwargs) -> None: ...
+    def decide_compress(self, data: bytes) -> Any: ...
+
+class CNONE(CompressorBase):
+    def __init__(self, level: int = ..., **kwargs) -> None: ...
+
+class ObfuscateSize(CompressorBase):
+    def __init__(self, level: int = ..., compressor: Any = ...) -> None: ...
+
+class ZLIB_legacy(CompressorBase):
+    def __init__(self, level: int = ..., **kwargs) -> None: ...
+    level: int
+
+class ZLIB(CompressorBase):
+    def __init__(self, level: int = ..., **kwargs) -> None: ...
+    level: int
+
+class LZ4(DecidingCompressor):
+    def __init__(self, level: int = ..., **kwargs) -> None: ...
+
+class LZMA(DecidingCompressor):
+    def __init__(self, level: int = ..., **kwargs) -> None: ...
+    level: int
+
+class ZSTD(DecidingCompressor):
+    def __init__(self, level: int = ..., **kwargs) -> None: ...
+    level: int
+
+LZ4_COMPRESSOR: Type[LZ4]
+NONE_COMPRESSOR: Type[CNONE]
diff --git a/src/borg/crypto/key.py b/src/borg/crypto/key.py
index 61a2b5385..e9f071abf 100644
--- a/src/borg/crypto/key.py
+++ b/src/borg/crypto/key.py
@@ -153,7 +153,7 @@ class KeyBase:
     STORAGE = KeyBlobStorage.NO_STORAGE
 
     # Seed for the buzhash chunker (borg.algorithms.chunker.Chunker)
-    # type: int
+    # type is int
     chunk_seed = None
 
     # Whether this *particular instance* is encrypted from a practical point of view,
diff --git a/src/borg/hashindex.pyi b/src/borg/hashindex.pyi
new file mode 100644
index 000000000..f368f39a5
--- /dev/null
+++ b/src/borg/hashindex.pyi
@@ -0,0 +1,88 @@
+from typing import NamedTuple, Tuple, Type, Union, IO, Iterator, Any
+
+API_VERSION: str
+
+PATH_OR_FILE = Union[str, IO]
+
+def hashindex_variant(fn: str) -> str: ...
+
+class IndexBase:
+    value_size: int
+    MAX_VALUE: int
+    MAX_LOAD_FACTOR: int
+    def __init__(
+        self, capacity: int = ..., path: PATH_OR_FILE = ..., permit_compact: bool = ..., usable: Union[int, float] = ...
+    ): ...
+    @classmethod
+    def read(cls, path: PATH_OR_FILE, permit_compact: bool = False): ...
+    def write(self, path: PATH_OR_FILE) -> None: ...
+    def clear(self) -> None: ...
+    def setdefault(self, key: bytes, value: bytes) -> None: ...
+    def __delitem__(self, key: bytes) -> None: ...
+    def get(self, key: bytes, default: Any = ...) -> Any: ...
+    def pop(self, key: bytes, default: Any = ...) -> Any: ...
+    def __len__(self) -> int: ...
+    def size(self) -> int: ...
+    def compact(self) -> Any: ...
+
+class ChunkIndexEntry(NamedTuple):
+    refcount: int
+    size: int
+    csize: int
+
+CIE = Union[Tuple[int, int, int], Type[ChunkIndexEntry]]
+
+class ChunkKeyIterator:
+    def __init__(self, keysize: int) -> None: ...
+    def __iter__(self) -> Iterator: ...
+    def __next__(self) -> Tuple[bytes, Type[ChunkIndexEntry]]: ...
+
+class ChunkIndex(IndexBase):
+    def add(self, key: bytes, refs: int, size: int, csize: int) -> None: ...
+    def decref(self, key: bytes) -> CIE: ...
+    def incref(self, key: bytes) -> CIE: ...
+    def iteritems(self, marker: bytes = ...) -> Iterator: ...
+    def merge(self, other_index) -> None: ...
+    def stats_against(self, master_index) -> Tuple: ...
+    def summarize(self) -> Tuple: ...
+    def zero_csize_ids(self) -> int: ...
+    def __contains__(self, key: bytes) -> bool: ...
+    def __getitem__(self, key: bytes) -> Type[ChunkIndexEntry]: ...
+    def __setitem__(self, key: bytes, value: CIE) -> None: ...
+
+class NSIndexEntry(NamedTuple):
+    segment: int
+    offset: int
+    size: int
+
+class NSKeyIterator:
+    def __init__(self, keysize: int) -> None: ...
+    def __iter__(self) -> Iterator: ...
+    def __next__(self) -> Tuple[bytes, Type[Any]]: ...
+
+class NSIndex(IndexBase):
+    def iteritems(self, *args, **kwargs) -> Iterator: ...
+    def __contains__(self, key: bytes) -> bool: ...
+    def __getitem__(self, key: bytes) -> Any: ...
+    def __setitem__(self, key: bytes, value: Any) -> None: ...
+
+class NSIndex1(IndexBase):  # legacy
+    def iteritems(self, *args, **kwargs) -> Iterator: ...
+    def __contains__(self, key: bytes) -> bool: ...
+    def __getitem__(self, key: bytes) -> Any: ...
+    def __setitem__(self, key: bytes, value: Any) -> None: ...
+
+class FuseVersionsIndex(IndexBase):
+    def __contains__(self, key: bytes) -> bool: ...
+    def __getitem__(self, key: bytes) -> Any: ...
+    def __setitem__(self, key: bytes, value: Any) -> None: ...
+
+class CacheSynchronizer:
+    csize_parts: int
+    csize_totals: int
+    num_files_parts: int
+    num_files_totals: int
+    size_parts: int
+    size_totals: int
+    def __init__(self, chunks_index: Any) -> None: ...
+    def feed(self, chunk: bytes) -> None: ...
diff --git a/src/borg/item.pyi b/src/borg/item.pyi
new file mode 100644
index 000000000..6e67b464c
--- /dev/null
+++ b/src/borg/item.pyi
@@ -0,0 +1,305 @@
+from typing import FrozenSet, Set, NamedTuple, Tuple, Mapping, Dict, List, Iterator, Callable, Any
+
+from .helpers import StableDict
+
+API_VERSION: str
+
+def want_bytes(v: Any, *, errors: str) -> bytes: ...
+def chunks_contents_equal(chunks1: Iterator, chunks2: Iterator) -> bool: ...
+
+class PropDict:
+    VALID_KEYS: Set[str] = ...
+    def __init__(self, data_dict: dict = None, internal_dict: dict = None, **kw) -> None: ...
+    def as_dict(self) -> StableDict: ...
+    def get(self, key: str, default: Any = None) -> Any: ...
+    def update(self, d: dict) -> None: ...
+    def update_internal(self, d: dict) -> None: ...
+    def __contains__(self, key: str) -> bool: ...
+    def __eq__(self, other: object) -> bool: ...
+
+class ArchiveItem(PropDict):
+    @property
+    def version(self) -> int: ...
+    @version.setter
+    def version(self, val: int) -> None: ...
+    @property
+    def name(self) -> str: ...
+    @name.setter
+    def name(self, val: str) -> None: ...
+    @property
+    def time(self) -> str: ...
+    @time.setter
+    def time(self, val: str) -> None: ...
+    @property
+    def time_end(self) -> str: ...
+    @time_end.setter
+    def time_end(self, val: str) -> None: ...
+    @property
+    def username(self) -> str: ...
+    @username.setter
+    def username(self, val: str) -> None: ...
+    @property
+    def hostname(self) -> str: ...
+    @hostname.setter
+    def hostname(self, val: str) -> None: ...
+    @property
+    def comment(self) -> str: ...
+    @comment.setter
+    def comment(self, val: str) -> None: ...
+    @property
+    def chunker_params(self) -> Tuple: ...
+    @chunker_params.setter
+    def chunker_params(self, val: Tuple) -> None: ...
+    @property
+    def cmdline(self) -> List[str]: ...
+    @cmdline.setter
+    def cmdline(self, val: List[str]) -> None: ...
+    @property
+    def recreate_cmdline(self) -> List[str]: ...
+    @recreate_cmdline.setter
+    def recreate_cmdline(self, val: List[str]) -> None: ...
+    @property
+    def recreate_args(self) -> Any: ...
+    @recreate_args.setter
+    def recreate_args(self, val: Any) -> None: ...
+    @property
+    def recreate_partial_chunks(self) -> Any: ...
+    @recreate_partial_chunks.setter
+    def recreate_partial_chunks(self, val: Any) -> None: ...
+    @property
+    def recreate_source_id(self) -> Any: ...
+    @recreate_source_id.setter
+    def recreate_source_id(self, val: Any) -> None: ...
+    @property
+    def nfiles(self) -> int: ...
+    @nfiles.setter
+    def nfiles(self, val: int) -> None: ...
+    @property
+    def nfiles_parts(self) -> int: ...
+    @nfiles_parts.setter
+    def nfiles_parts(self, val: int) -> None: ...
+    @property
+    def size(self) -> int: ...
+    @size.setter
+    def size(self, val: int) -> None: ...
+    @property
+    def size_parts(self) -> int: ...
+    @size_parts.setter
+    def size_parts(self, val: int) -> None: ...
+    @property
+    def csize(self) -> int: ...
+    @csize.setter
+    def csize(self, val: int) -> None: ...
+    @property
+    def csize_parts(self) -> int: ...
+    @csize_parts.setter
+    def csize_parts(self, val: int) -> None: ...
+    @property
+    def items(self) -> List: ...
+    @items.setter
+    def items(self, val: List) -> None: ...
+
+class ChunkListEntry(NamedTuple):
+    id: bytes
+    size: int
+    csize: int
+
+class Item(PropDict):
+    @property
+    def path(self) -> str: ...
+    @path.setter
+    def path(self, val: str) -> None: ...
+    @property
+    def source(self) -> str: ...
+    @source.setter
+    def source(self, val: str) -> None: ...
+    def is_dir(self) -> bool: ...
+    def is_link(self) -> bool: ...
+    def _is_type(self, typetest: Callable) -> bool: ...
+    @classmethod
+    def create_deleted(self, path) -> Item: ...
+    @classmethod
+    def from_optr(self, optr: Any) -> Item: ...
+    def to_optr(self) -> Any: ...
+    @property
+    def atime(self) -> int: ...
+    @atime.setter
+    def atime(self, val: int) -> None: ...
+    @property
+    def ctime(self) -> int: ...
+    @ctime.setter
+    def ctime(self, val: int) -> None: ...
+    @property
+    def mtime(self) -> int: ...
+    @mtime.setter
+    def mtime(self, val: int) -> None: ...
+    @property
+    def birthtime(self) -> int: ...
+    @birthtime.setter
+    def birthtime(self, val: int) -> None: ...
+    @property
+    def xattrs(self) -> StableDict: ...
+    @xattrs.setter
+    def xattrs(self, val: StableDict) -> None: ...
+    @property
+    def acl_access(self) -> bytes: ...
+    @acl_access.setter
+    def acl_access(self, val: bytes) -> None: ...
+    @property
+    def acl_default(self) -> bytes: ...
+    @acl_default.setter
+    def acl_default(self, val: bytes) -> None: ...
+    @property
+    def acl_extended(self) -> bytes: ...
+    @acl_extended.setter
+    def acl_extended(self, val: bytes) -> None: ...
+    @property
+    def acl_nfs4(self) -> bytes: ...
+    @acl_nfs4.setter
+    def acl_nfs4(self, val: bytes) -> None: ...
+    @property
+    def bsdflags(self) -> int: ...
+    @bsdflags.setter
+    def bsdflags(self, val: int) -> None: ...
+    @property
+    def chunks(self) -> List: ...
+    @chunks.setter
+    def chunks(self, val: List) -> None: ...
+    @property
+    def chunks_healthy(self) -> List: ...
+    @chunks_healthy.setter
+    def chunks_healthy(self, val: List) -> None: ...
+    @property
+    def deleted(self) -> bool: ...
+    @deleted.setter
+    def deleted(self, val: bool) -> None: ...
+    @property
+    def hardlink_master(self) -> bool: ...
+    @hardlink_master.setter
+    def hardlink_master(self, val: bool) -> None: ...
+    @property
+    def uid(self) -> int: ...
+    @uid.setter
+    def uid(self, val: int) -> None: ...
+    @property
+    def gid(self) -> int: ...
+    @gid.setter
+    def gid(self, val: int) -> None: ...
+    @property
+    def user(self) -> str: ...
+    @user.setter
+    def user(self, val: str) -> None: ...
+    @property
+    def group(self) -> str: ...
+    @group.setter
+    def group(self, val: str) -> None: ...
+    @property
+    def mode(self) -> int: ...
+    @mode.setter
+    def mode(self, val: int) -> None: ...
+    @property
+    def rdev(self) -> int: ...
+    @rdev.setter
+    def rdev(self, val: int) -> None: ...
+    @property
+    def nlink(self) -> int: ...
+    @nlink.setter
+    def nlink(self, val: int) -> None: ...
+    @property
+    def size(self) -> int: ...
+    @size.setter
+    def size(self, val: int) -> None: ...
+    def get_size(
+        self,
+        hardlink_masters=...,
+        memorize: bool = ...,
+        compressed: bool = ...,
+        from_chunks: bool = ...,
+        consider_ids: List[bytes] = ...,
+    ) -> int: ...
+    @property
+    def part(self) -> int: ...
+    @part.setter
+    def part(self, val: int) -> None: ...
+
+class ManifestItem(PropDict):
+    @property
+    def version(self) -> int: ...
+    @version.setter
+    def version(self, val: int) -> None: ...
+    @property
+    def timestamp(self) -> str: ...
+    @timestamp.setter
+    def timestamp(self, val: str) -> None: ...
+    @property
+    def archives(self) -> Mapping[bytes, dict]: ...
+    @archives.setter
+    def archives(self, val: Mapping[bytes, dict]) -> None: ...
+    @property
+    def config(self) -> Dict: ...
+    @config.setter
+    def config(self, val: Dict) -> None: ...
+    @property
+    def item_keys(self) -> Tuple: ...
+    @item_keys.setter
+    def item_keys(self, val: Tuple) -> None: ...
+
+class ItemDiff:
+    def __init__(self, *args, **kwargs) -> None: ...
+    def _chunk_content_equal(self, c1: Iterator, c2: Iterator) -> bool: ...
+
+class Key(PropDict):
+    @property
+    def version(self) -> int: ...
+    @version.setter
+    def version(self, val: int) -> None: ...
+    @property
+    def chunk_seed(self) -> int: ...
+    @chunk_seed.setter
+    def chunk_seed(self, val: int) -> None: ...
+    @property
+    def tam_required(self) -> bool: ...
+    @tam_required.setter
+    def tam_required(self, val: bool) -> None: ...
+    @property
+    def enc_hmac_key(self) -> bytes: ...
+    @enc_hmac_key.setter
+    def enc_hmac_key(self, val: bytes) -> None: ...
+    @property
+    def enc_key(self) -> bytes: ...
+    @enc_key.setter
+    def enc_key(self, val: bytes) -> None: ...
+    @property
+    def id_key(self) -> bytes: ...
+    @id_key.setter
+    def id_key(self, val: bytes) -> None: ...
+    @property
+    def repository_id(self) -> bytes: ...
+    @repository_id.setter
+    def repository_id(self, val: bytes) -> None: ...
+
+class EncryptedKey(PropDict):
+    @property
+    def version(self) -> int: ...
+    @version.setter
+    def version(self, val: int) -> None: ...
+    @property
+    def algorithm(self) -> str: ...
+    @algorithm.setter
+    def algorithm(self, val: str) -> None: ...
+    @property
+    def salt(self) -> bytes: ...
+    @salt.setter
+    def salt(self, val: bytes) -> None: ...
+    @property
+    def iterations(self) -> int: ...
+    @iterations.setter
+    def iterations(self, val: int) -> None: ...
+    @property
+    def data(self) -> bytes: ...
+    @data.setter
+    def data(self, val: bytes) -> None: ...
+    @property
+    def hash(self) -> bytes: ...
+    @hash.setter
+    def hash(self, val: bytes) -> None: ...
diff --git a/tox.ini b/tox.ini
index 37ed3b142..861c24322 100644
--- a/tox.ini
+++ b/tox.ini
@@ -29,3 +29,11 @@ changedir =
 deps =
     flake8
 commands = flake8 src scripts conftest.py
+
+[testenv:mypy]
+changedir =
+deps =
+    pytest
+    mypy
+    pkgconfig
+commands = mypy

From f71f26ddfd96dc52870ce227e4120d4ebd2a30e8 Mon Sep 17 00:00:00 2001
From: Thomas Waldmann <tw@waldmann-edv.de>
Date: Fri, 15 Jul 2022 13:15:11 +0200
Subject: [PATCH 152/160] mypy: fix platform package

clean up imports, remove unused stuff
---
 src/borg/platform/__init__.py | 60 +++++++++++++++++++++++------------
 src/borg/platform/base.py     | 12 -------
 2 files changed, 40 insertions(+), 32 deletions(-)

diff --git a/src/borg/platform/__init__.py b/src/borg/platform/__init__.py
index 6692960fe..06ff8e42a 100644
--- a/src/borg/platform/__init__.py
+++ b/src/borg/platform/__init__.py
@@ -6,26 +6,9 @@ Public APIs are documented in platform.base.
 
 from ..platformflags import is_win32, is_linux, is_freebsd, is_darwin
 
-from .base import listxattr, getxattr, setxattr, ENOATTR
-from .base import acl_get, acl_set
-from .base import set_flags, get_flags
-from .base import SaveFile, SyncFile, sync_dir, fdatasync, safe_fadvise
-from .base import swidth, API_VERSION
-from .base import process_alive, get_process_id, local_pid_alive, fqdn, hostname, hostid
-
-OS_API_VERSION = API_VERSION
-
-if not is_win32:
-    from .posix import process_alive, local_pid_alive
-
-    # posix swidth implementation works for: linux, freebsd, darwin, openindiana, cygwin
-    from .posix import swidth
-    from .posix import get_errno
-    from .posix import uid2user, user2uid, gid2group, group2gid, getosusername
-
-else:
-    from .windows import process_alive, local_pid_alive
-    from .windows import uid2user, user2uid, gid2group, group2gid, getosusername
+from .base import ENOATTR, API_VERSION
+from .base import SaveFile, sync_dir, fdatasync, safe_fadvise
+from .base import get_process_id, fqdn, hostname, hostid
 
 if is_linux:  # pragma: linux only
     from .linux import API_VERSION as OS_API_VERSION
@@ -33,11 +16,48 @@ if is_linux:  # pragma: linux only
     from .linux import acl_get, acl_set
     from .linux import set_flags, get_flags
     from .linux import SyncFile
+    from .posix import process_alive, local_pid_alive
+    from .posix import swidth
+    from .posix import get_errno
+    from .posix import uid2user, user2uid, gid2group, group2gid, getosusername
 elif is_freebsd:  # pragma: freebsd only
     from .freebsd import API_VERSION as OS_API_VERSION
     from .freebsd import listxattr, getxattr, setxattr
     from .freebsd import acl_get, acl_set
+    from .base import set_flags, get_flags
+    from .base import SyncFile
+    from .posix import process_alive, local_pid_alive
+    from .posix import swidth
+    from .posix import get_errno
+    from .posix import uid2user, user2uid, gid2group, group2gid, getosusername
 elif is_darwin:  # pragma: darwin only
     from .darwin import API_VERSION as OS_API_VERSION
     from .darwin import listxattr, getxattr, setxattr
     from .darwin import acl_get, acl_set
+    from .base import set_flags, get_flags
+    from .base import SyncFile
+    from .posix import process_alive, local_pid_alive
+    from .posix import swidth
+    from .posix import get_errno
+    from .posix import uid2user, user2uid, gid2group, group2gid, getosusername
+elif not is_win32:  # pragma: posix only
+    # generic stuff for all other posix OSes
+    OS_API_VERSION = API_VERSION
+    from .base import listxattr, getxattr, setxattr
+    from .base import acl_get, acl_set
+    from .base import set_flags, get_flags
+    from .base import SyncFile
+    from .posix import process_alive, local_pid_alive
+    from .posix import swidth
+    from .posix import get_errno
+    from .posix import uid2user, user2uid, gid2group, group2gid, getosusername
+else:  # pragma: win32 only
+    # win32 specific stuff
+    OS_API_VERSION = API_VERSION
+    from .base import listxattr, getxattr, setxattr
+    from .base import acl_get, acl_set
+    from .base import set_flags, get_flags
+    from .base import SyncFile
+    from .windows import process_alive, local_pid_alive
+    from .base import swidth
+    from .windows import uid2user, user2uid, gid2group, group2gid, getosusername
diff --git a/src/borg/platform/base.py b/src/borg/platform/base.py
index 15b778729..c4edcfb6a 100644
--- a/src/borg/platform/base.py
+++ b/src/borg/platform/base.py
@@ -323,15 +323,3 @@ def get_process_id():
     thread_id = 0
     pid = os.getpid()
     return hostid, pid, thread_id
-
-
-def process_alive(host, pid, thread):
-    """
-    Check if the (host, pid, thread_id) combination corresponds to a potentially alive process.
-    """
-    raise NotImplementedError
-
-
-def local_pid_alive(pid):
-    """Return whether *pid* is alive."""
-    raise NotImplementedError

From 366ef73f88a9ced17fa5854fa0c947c9bcce7bd6 Mon Sep 17 00:00:00 2001
From: Thomas Waldmann <tw@waldmann-edv.de>
Date: Fri, 15 Jul 2022 13:20:42 +0200
Subject: [PATCH 153/160] mypy: rename yes module to yes_no to avoid name
 collision

---
 src/borg/helpers/__init__.py           | 2 +-
 src/borg/helpers/{yes.py => yes_no.py} | 0
 2 files changed, 1 insertion(+), 1 deletion(-)
 rename src/borg/helpers/{yes.py => yes_no.py} (100%)

diff --git a/src/borg/helpers/__init__.py b/src/borg/helpers/__init__.py
index 67ee948e0..7fdb43508 100644
--- a/src/borg/helpers/__init__.py
+++ b/src/borg/helpers/__init__.py
@@ -16,7 +16,7 @@ from .parseformat import *  # NOQA
 from .process import *  # NOQA
 from .progress import *  # NOQA
 from .time import *  # NOQA
-from .yes import *  # NOQA
+from .yes_no import *  # NOQA
 
 from .msgpack import is_slow_msgpack, is_supported_msgpack, get_limited_unpacker
 from . import msgpack
diff --git a/src/borg/helpers/yes.py b/src/borg/helpers/yes_no.py
similarity index 100%
rename from src/borg/helpers/yes.py
rename to src/borg/helpers/yes_no.py

From b8e48c503689f72eaf6e58cac0d9c128c41916cb Mon Sep 17 00:00:00 2001
From: Thomas Waldmann <tw@waldmann-edv.de>
Date: Fri, 15 Jul 2022 13:26:35 +0200
Subject: [PATCH 154/160] mypy: fixes / annotations

---
 src/borg/__init__.py              |   2 +-
 src/borg/cache.py                 |   2 +-
 src/borg/crypto/file_integrity.py |   5 +-
 src/borg/crypto/key.py            |  12 ++--
 src/borg/fuse.py                  |   4 +-
 src/borg/helpers/__init__.py      |  42 ++++++++---
 src/borg/helpers/manifest.py      |   5 +-
 src/borg/helpers/misc.py          |   4 +-
 src/borg/helpers/parseformat.py   |   2 +-
 src/borg/helpers/progress.py      |   2 +-
 src/borg/logger.py                | 115 +++++++++++++++---------------
 src/borg/patterns.py              |   2 +-
 src/borg/platform/base.py         |   2 +-
 src/borg/remote.py                |   2 +-
 src/borg/testsuite/__init__.py    |   2 +-
 src/borg/testsuite/archiver.py    |   2 +-
 src/borg/testsuite/platform.py    |   2 +-
 src/borg/testsuite/remote.py      |   4 +-
 tox.ini                           |   1 +
 19 files changed, 118 insertions(+), 94 deletions(-)

diff --git a/src/borg/__init__.py b/src/borg/__init__.py
index d05eff6e0..e1f770290 100644
--- a/src/borg/__init__.py
+++ b/src/borg/__init__.py
@@ -4,7 +4,7 @@ from ._version import version as __version__
 
 
 _v = parse_version(__version__)
-__version_tuple__ = _v._version.release
+__version_tuple__ = _v._version.release  # type: ignore
 
 # assert that all semver components are integers
 # this is mainly to show errors when people repackage poorly
diff --git a/src/borg/cache.py b/src/borg/cache.py
index 5c5d5e33e..a7b2ae22e 100644
--- a/src/borg/cache.py
+++ b/src/borg/cache.py
@@ -1109,7 +1109,7 @@ Chunk index:    {0.total_unique_chunks:20d}             unknown"""
     def __exit__(self, exc_type, exc_val, exc_tb):
         pass
 
-    files = None
+    files = None  # type: ignore
     cache_mode = "d"
 
     def file_known_and_unchanged(self, hashed_path, path_hash, st):
diff --git a/src/borg/crypto/file_integrity.py b/src/borg/crypto/file_integrity.py
index e497b6af5..f54ea8a1f 100644
--- a/src/borg/crypto/file_integrity.py
+++ b/src/borg/crypto/file_integrity.py
@@ -3,6 +3,7 @@ import io
 import json
 import os
 from hmac import compare_digest
+from typing import Callable
 
 from ..helpers import IntegrityError
 from ..logger import create_logger
@@ -54,8 +55,8 @@ class FileHashingWrapper(FileLikeWrapper):
     are illegal.
     """
 
-    ALGORITHM = None
-    FACTORY = None
+    ALGORITHM: str = None
+    FACTORY: Callable = None
 
     def __init__(self, backing_fd, write):
         self.fd = backing_fd
diff --git a/src/borg/crypto/key.py b/src/borg/crypto/key.py
index e9f071abf..882c595e2 100644
--- a/src/borg/crypto/key.py
+++ b/src/borg/crypto/key.py
@@ -3,7 +3,7 @@ import os
 import textwrap
 from binascii import a2b_base64, b2a_base64, hexlify
 from hashlib import sha256, pbkdf2_hmac
-from typing import Literal
+from typing import Literal, Callable, Sequence
 
 from ..logger import create_logger
 
@@ -139,9 +139,9 @@ def uses_same_id_hash(other_key, key):
 
 class KeyBase:
     # Numeric key type ID, must fit in one byte.
-    TYPE = None  # override in subclasses
+    TYPE: int = None  # override in subclasses
     # set of key type IDs the class can handle as input
-    TYPES_ACCEPTABLE = None  # override in subclasses
+    TYPES_ACCEPTABLE: set[int] = None  # override in subclasses
 
     # Human-readable name
     NAME = "UNDEFINED"
@@ -154,7 +154,7 @@ class KeyBase:
 
     # Seed for the buzhash chunker (borg.algorithms.chunker.Chunker)
     # type is int
-    chunk_seed = None
+    chunk_seed: int = None
 
     # Whether this *particular instance* is encrypted from a practical point of view,
     # i.e. when it's using encryption with a empty passphrase, then
@@ -356,7 +356,7 @@ class AESKeyBase(KeyBase):
 
     PAYLOAD_OVERHEAD = 1 + 32 + 8  # TYPE + HMAC + NONCE
 
-    CIPHERSUITE = None  # override in derived class
+    CIPHERSUITE: Callable = None  # override in derived class
 
     logically_encrypted = True
 
@@ -839,7 +839,7 @@ class AEADKeyBase(KeyBase):
 
     PAYLOAD_OVERHEAD = 1 + 1 + 6 + 24 + 16  # [bytes], see Layout
 
-    CIPHERSUITE = None  # override in subclass
+    CIPHERSUITE: Callable = None  # override in subclass
 
     logically_encrypted = True
 
diff --git a/src/borg/fuse.py b/src/borg/fuse.py
index 2b7a222db..09ebd5bc4 100644
--- a/src/borg/fuse.py
+++ b/src/borg/fuse.py
@@ -706,7 +706,7 @@ class FuseOperations(llfuse.Operations, FuseBackend):
     # note: we can't have a generator (with yield) and not a generator (async) in the same method
     if has_pyfuse3:
 
-        async def readdir(self, fh, off, token):
+        async def readdir(self, fh, off, token):  # type: ignore[misc]
             entries = [(b".", fh), (b"..", self.parent[fh])]
             entries.extend(self.contents[fh].items())
             for i, (name, inode) in enumerate(entries[off:], off):
@@ -716,7 +716,7 @@ class FuseOperations(llfuse.Operations, FuseBackend):
 
     else:
 
-        def readdir(self, fh, off):
+        def readdir(self, fh, off):  # type: ignore[misc]
             entries = [(b".", fh), (b"..", self.parent[fh])]
             entries.extend(self.contents[fh].items())
             for i, (name, inode) in enumerate(entries[off:], off):
diff --git a/src/borg/helpers/__init__.py b/src/borg/helpers/__init__.py
index 7fdb43508..e808bc213 100644
--- a/src/borg/helpers/__init__.py
+++ b/src/borg/helpers/__init__.py
@@ -5,18 +5,38 @@ that did not fit better elsewhere.
 Code used to be in borg/helpers.py but was split into the modules in this
 package, which are imported into here for compatibility.
 """
+import os
 
-from .checks import *  # NOQA
-from .datastruct import *  # NOQA
-from .errors import *  # NOQA
-from .fs import *  # NOQA
-from .manifest import *  # NOQA
-from .misc import *  # NOQA
-from .parseformat import *  # NOQA
-from .process import *  # NOQA
-from .progress import *  # NOQA
-from .time import *  # NOQA
-from .yes_no import *  # NOQA
+from ..constants import *  # NOQA
+from .checks import check_extension_modules, check_python
+from .datastruct import StableDict, Buffer, EfficientCollectionQueue
+from .errors import Error, ErrorWithTraceback, IntegrityError, DecompressionError
+from .fs import ensure_dir, get_security_dir, get_keys_dir, get_base_dir, get_cache_dir, get_config_dir
+from .fs import dir_is_tagged, dir_is_cachedir, make_path_safe, scandir_inorder
+from .fs import secure_erase, safe_unlink, dash_open, os_open, os_stat, umount
+from .fs import O_, flags_root, flags_dir, flags_special_follow, flags_special, flags_base, flags_normal, flags_noatime
+from .fs import HardLinkManager
+from .manifest import Manifest, NoManifestError, MandatoryFeatureUnsupported, AI_HUMAN_SORT_KEYS
+from .misc import prune_within, prune_split, PRUNING_PATTERNS, sysinfo, log_multi, consume, get_tar_filter
+from .misc import ChunkIteratorFileWrapper, open_item, chunkit, iter_separated, ErrorIgnoringTextIOWrapper
+from .parseformat import bin_to_hex, safe_encode, safe_decode
+from .parseformat import remove_surrogates, eval_escapes, decode_dict, positive_int_validator, interval
+from .parseformat import ChunkerParams, FilesCacheMode, partial_format, DatetimeWrapper
+from .parseformat import format_file_size, parse_file_size, FileSize, parse_storage_quota
+from .parseformat import sizeof_fmt, sizeof_fmt_iec, sizeof_fmt_decimal
+from .parseformat import format_line, replace_placeholders, PlaceholderError
+from .parseformat import PrefixSpec, GlobSpec, CommentSpec, SortBySpec, NameSpec
+from .parseformat import format_archive, parse_stringified_list, clean_lines
+from .parseformat import Location, location_validator, archivename_validator
+from .parseformat import BaseFormatter, ArchiveFormatter, ItemFormatter, file_status
+from .parseformat import swidth_slice, ellipsis_truncate
+from .parseformat import BorgJsonEncoder, basic_json_data, json_print, json_dump, prepare_dump_dict
+from .process import daemonize, daemonizing, signal_handler, raising_signal_handler, sig_int, SigHup, SigTerm
+from .process import popen_with_error_handling, is_terminal, prepare_subprocess_env, create_filter_process
+from .progress import ProgressIndicatorPercent, ProgressIndicatorEndless, ProgressIndicatorMessage
+from .time import parse_timestamp, timestamp, safe_timestamp, safe_s, safe_ns, MAX_S, SUPPORT_32BIT_PLATFORMS
+from .time import format_time, format_timedelta, isoformat_time, to_localtime, OutputTimestamp
+from .yes_no import yes, TRUISH, FALSISH, DEFAULTISH
 
 from .msgpack import is_slow_msgpack, is_supported_msgpack, get_limited_unpacker
 from . import msgpack
diff --git a/src/borg/helpers/manifest.py b/src/borg/helpers/manifest.py
index 1aeaf91fa..d81b0a738 100644
--- a/src/borg/helpers/manifest.py
+++ b/src/borg/helpers/manifest.py
@@ -5,6 +5,7 @@ import re
 from collections import abc, namedtuple
 from datetime import datetime, timedelta
 from operator import attrgetter
+from typing import Sequence, FrozenSet
 
 from .errors import Error
 
@@ -158,9 +159,9 @@ class Manifest:
         # count and the need to be able to find all (directly and indirectly) referenced chunks of a given archive.
         DELETE = "delete"
 
-    NO_OPERATION_CHECK = tuple()
+    NO_OPERATION_CHECK: Sequence[Operation] = tuple()
 
-    SUPPORTED_REPO_FEATURES = frozenset([])
+    SUPPORTED_REPO_FEATURES: FrozenSet[str] = frozenset([])
 
     MANIFEST_ID = b"\0" * 32
 
diff --git a/src/borg/helpers/misc.py b/src/borg/helpers/misc.py
index ae40974db..3143540a4 100644
--- a/src/borg/helpers/misc.py
+++ b/src/borg/helpers/misc.py
@@ -236,12 +236,12 @@ def iter_separated(fd, sep=None, read_size=4096):
     sep = sep or ("\n" if is_str else b"\n")
     while len(buf) > 0:
         part2, *items = buf.split(sep)
-        *full, part = (part + part2, *items)
+        *full, part = (part + part2, *items)  # type: ignore
         yield from full
         buf = fd.read(read_size)
     # won't yield an empty part if stream ended with `sep`
     # or if there was no data before EOF
-    if len(part) > 0:
+    if len(part) > 0:  # type: ignore[arg-type]
         yield part
 
 
diff --git a/src/borg/helpers/parseformat.py b/src/borg/helpers/parseformat.py
index 69ea17237..5c1b0beaa 100644
--- a/src/borg/helpers/parseformat.py
+++ b/src/borg/helpers/parseformat.py
@@ -694,7 +694,7 @@ class ArchiveFormatter(BaseFormatter):
 class ItemFormatter(BaseFormatter):
     # we provide the hash algos from python stdlib (except shake_*) and additionally xxh64.
     # shake_* is not provided because it uses an incompatible .digest() method to support variable length.
-    hash_algorithms = hashlib.algorithms_guaranteed.union({"xxh64"}).difference({"shake_128", "shake_256"})
+    hash_algorithms = set(hashlib.algorithms_guaranteed).union({"xxh64"}).difference({"shake_128", "shake_256"})
     KEY_DESCRIPTIONS = {
         "bpath": "verbatim POSIX path, can contain any character except NUL",
         "path": "path interpreted as text (might be missing non-text characters, see bpath)",
diff --git a/src/borg/helpers/progress.py b/src/borg/helpers/progress.py
index 11c45c80b..fb2e0fc5e 100644
--- a/src/borg/helpers/progress.py
+++ b/src/borg/helpers/progress.py
@@ -21,7 +21,7 @@ def justify_to_terminal_size(message):
 
 class ProgressIndicatorBase:
     LOGGER = "borg.output.progress"
-    JSON_TYPE = None
+    JSON_TYPE: str = None
     json = False
 
     operation_id_counter = 0
diff --git a/src/borg/logger.py b/src/borg/logger.py
index 492b90a27..b10ee0d3e 100644
--- a/src/borg/logger.py
+++ b/src/borg/logger.py
@@ -135,7 +135,64 @@ def find_parent_module():
         return __name__
 
 
-def create_logger(name=None):
+class LazyLogger:
+    def __init__(self, name=None):
+        self.__name = name or find_parent_module()
+        self.__real_logger = None
+
+    @property
+    def __logger(self):
+        if self.__real_logger is None:
+            if not configured:
+                raise Exception("tried to call a logger before setup_logging() was called")
+            self.__real_logger = logging.getLogger(self.__name)
+            if self.__name.startswith("borg.debug.") and self.__real_logger.level == logging.NOTSET:
+                self.__real_logger.setLevel("WARNING")
+        return self.__real_logger
+
+    def getChild(self, suffix):
+        return LazyLogger(self.__name + "." + suffix)
+
+    def setLevel(self, *args, **kw):
+        return self.__logger.setLevel(*args, **kw)
+
+    def log(self, *args, **kw):
+        if "msgid" in kw:
+            kw.setdefault("extra", {})["msgid"] = kw.pop("msgid")
+        return self.__logger.log(*args, **kw)
+
+    def exception(self, *args, **kw):
+        if "msgid" in kw:
+            kw.setdefault("extra", {})["msgid"] = kw.pop("msgid")
+        return self.__logger.exception(*args, **kw)
+
+    def debug(self, *args, **kw):
+        if "msgid" in kw:
+            kw.setdefault("extra", {})["msgid"] = kw.pop("msgid")
+        return self.__logger.debug(*args, **kw)
+
+    def info(self, *args, **kw):
+        if "msgid" in kw:
+            kw.setdefault("extra", {})["msgid"] = kw.pop("msgid")
+        return self.__logger.info(*args, **kw)
+
+    def warning(self, *args, **kw):
+        if "msgid" in kw:
+            kw.setdefault("extra", {})["msgid"] = kw.pop("msgid")
+        return self.__logger.warning(*args, **kw)
+
+    def error(self, *args, **kw):
+        if "msgid" in kw:
+            kw.setdefault("extra", {})["msgid"] = kw.pop("msgid")
+        return self.__logger.error(*args, **kw)
+
+    def critical(self, *args, **kw):
+        if "msgid" in kw:
+            kw.setdefault("extra", {})["msgid"] = kw.pop("msgid")
+        return self.__logger.critical(*args, **kw)
+
+
+def create_logger(name: str = None) -> LazyLogger:
     """lazily create a Logger object with the proper path, which is returned by
     find_parent_module() by default, or is provided via the commandline
 
@@ -152,62 +209,6 @@ def create_logger(name=None):
     If you try, you'll get an exception.
     """
 
-    class LazyLogger:
-        def __init__(self, name=None):
-            self.__name = name or find_parent_module()
-            self.__real_logger = None
-
-        @property
-        def __logger(self):
-            if self.__real_logger is None:
-                if not configured:
-                    raise Exception("tried to call a logger before setup_logging() was called")
-                self.__real_logger = logging.getLogger(self.__name)
-                if self.__name.startswith("borg.debug.") and self.__real_logger.level == logging.NOTSET:
-                    self.__real_logger.setLevel("WARNING")
-            return self.__real_logger
-
-        def getChild(self, suffix):
-            return LazyLogger(self.__name + "." + suffix)
-
-        def setLevel(self, *args, **kw):
-            return self.__logger.setLevel(*args, **kw)
-
-        def log(self, *args, **kw):
-            if "msgid" in kw:
-                kw.setdefault("extra", {})["msgid"] = kw.pop("msgid")
-            return self.__logger.log(*args, **kw)
-
-        def exception(self, *args, **kw):
-            if "msgid" in kw:
-                kw.setdefault("extra", {})["msgid"] = kw.pop("msgid")
-            return self.__logger.exception(*args, **kw)
-
-        def debug(self, *args, **kw):
-            if "msgid" in kw:
-                kw.setdefault("extra", {})["msgid"] = kw.pop("msgid")
-            return self.__logger.debug(*args, **kw)
-
-        def info(self, *args, **kw):
-            if "msgid" in kw:
-                kw.setdefault("extra", {})["msgid"] = kw.pop("msgid")
-            return self.__logger.info(*args, **kw)
-
-        def warning(self, *args, **kw):
-            if "msgid" in kw:
-                kw.setdefault("extra", {})["msgid"] = kw.pop("msgid")
-            return self.__logger.warning(*args, **kw)
-
-        def error(self, *args, **kw):
-            if "msgid" in kw:
-                kw.setdefault("extra", {})["msgid"] = kw.pop("msgid")
-            return self.__logger.error(*args, **kw)
-
-        def critical(self, *args, **kw):
-            if "msgid" in kw:
-                kw.setdefault("extra", {})["msgid"] = kw.pop("msgid")
-            return self.__logger.critical(*args, **kw)
-
     return LazyLogger(name)
 
 
diff --git a/src/borg/patterns.py b/src/borg/patterns.py
index 749430190..c744288b9 100644
--- a/src/borg/patterns.py
+++ b/src/borg/patterns.py
@@ -172,7 +172,7 @@ def normalize_path(path):
 class PatternBase:
     """Shared logic for inclusion/exclusion patterns."""
 
-    PREFIX = NotImplemented
+    PREFIX: str = None
 
     def __init__(self, pattern, recurse_dir=False):
         self.pattern_orig = pattern
diff --git a/src/borg/platform/base.py b/src/borg/platform/base.py
index c4edcfb6a..7b10d594c 100644
--- a/src/borg/platform/base.py
+++ b/src/borg/platform/base.py
@@ -82,7 +82,7 @@ def acl_set(path, item, numeric_ids=False, fd=None):
 
 
 try:
-    from os import lchflags
+    from os import lchflags  # type: ignore[attr-defined]
 
     def set_flags(path, bsd_flags, fd=None):
         lchflags(path, bsd_flags)
diff --git a/src/borg/remote.py b/src/borg/remote.py
index c55d363a8..bb1bdfa76 100644
--- a/src/borg/remote.py
+++ b/src/borg/remote.py
@@ -495,7 +495,7 @@ def api(*, since, **kwargs_decorator):
 
 
 class RemoteRepository:
-    extra_test_args = []
+    extra_test_args = []  # type: ignore
 
     class RPCError(Exception):
         def __init__(self, unpacked):
diff --git a/src/borg/testsuite/__init__.py b/src/borg/testsuite/__init__.py
index c98fd5968..350b64cae 100644
--- a/src/borg/testsuite/__init__.py
+++ b/src/borg/testsuite/__init__.py
@@ -168,7 +168,7 @@ class BaseTestCase(unittest.TestCase):
     if raises:
         assert_raises = staticmethod(raises)
     else:
-        assert_raises = unittest.TestCase.assertRaises
+        assert_raises = unittest.TestCase.assertRaises  # type: ignore
 
     @contextmanager
     def assert_creates_file(self, path):
diff --git a/src/borg/testsuite/archiver.py b/src/borg/testsuite/archiver.py
index d4437b230..1f8158936 100644
--- a/src/borg/testsuite/archiver.py
+++ b/src/borg/testsuite/archiver.py
@@ -250,7 +250,7 @@ def test_disk_full(cmd):
 
 
 class ArchiverTestCaseBase(BaseTestCase):
-    EXE = None  # python source based
+    EXE: str = None  # python source based
     FORK_DEFAULT = False
     prefix = ""
 
diff --git a/src/borg/testsuite/platform.py b/src/borg/testsuite/platform.py
index 0b0f1d047..1f03c9a8f 100644
--- a/src/borg/testsuite/platform.py
+++ b/src/borg/testsuite/platform.py
@@ -38,7 +38,7 @@ other::r--
     "ascii"
 )
 
-_acls_working = None
+# _acls_working = None
 
 
 def fakeroot_detected():
diff --git a/src/borg/testsuite/remote.py b/src/borg/testsuite/remote.py
index 125cd9260..348f6f202 100644
--- a/src/borg/testsuite/remote.py
+++ b/src/borg/testsuite/remote.py
@@ -113,9 +113,9 @@ class TestRepositoryCache:
 
         # Force cache to back off
         qsl = cache.query_size_limit
-        cache.query_size_limit = query_size_limit
+        cache.query_size_limit = query_size_limit  # type: ignore[assignment]
         cache.backoff()
-        cache.query_size_limit = qsl
+        cache.query_size_limit = qsl  # type: ignore[assignment]
         # Evicted H(1) and H(2)
         assert cache.evictions == 2
         assert H(1) not in cache.cache
diff --git a/tox.ini b/tox.ini
index 861c24322..653e160f8 100644
--- a/tox.ini
+++ b/tox.ini
@@ -36,4 +36,5 @@ deps =
     pytest
     mypy
     pkgconfig
+    types-python-dateutil
 commands = mypy

From 47c2672a647ee8080edf60cfe698f6da1a90b35e Mon Sep 17 00:00:00 2001
From: Thomas Waldmann <tw@waldmann-edv.de>
Date: Fri, 15 Jul 2022 16:02:45 +0200
Subject: [PATCH 155/160] ssh:// URLs: remove support for /~otheruser/, see
 #6855

If you used this, just replace it by:

ssh://user@host:port/home/otheruser/
---
 docs/usage/general/repository-urls.rst.inc | 2 --
 src/borg/remote.py                         | 4 +---
 src/borg/testsuite/helpers.py              | 5 -----
 3 files changed, 1 insertion(+), 10 deletions(-)

diff --git a/docs/usage/general/repository-urls.rst.inc b/docs/usage/general/repository-urls.rst.inc
index 7bca942d3..2d1fc27d5 100644
--- a/docs/usage/general/repository-urls.rst.inc
+++ b/docs/usage/general/repository-urls.rst.inc
@@ -20,8 +20,6 @@ Note: you may also prepend a ``file://`` to a filesystem path to get URL style.
 
 ``ssh://user@host:port/~/path/to/repo`` - path relative to user's home directory
 
-``ssh://user@host:port/~other/path/to/repo`` - path relative to other's home directory
-
 
 If you frequently need the same repo URL, it is a good idea to set the
 ``BORG_REPO`` environment variable to set a default for the repo URL:
diff --git a/src/borg/remote.py b/src/borg/remote.py
index bb1bdfa76..b3a7555e0 100644
--- a/src/borg/remote.py
+++ b/src/borg/remote.py
@@ -332,10 +332,8 @@ class RepositoryServer:  # pragma: no cover
     def _resolve_path(self, path):
         if isinstance(path, bytes):
             path = os.fsdecode(path)
-        if path.startswith("/~/"):  # /~/x = path x relative to home dir
+        if path.startswith("/~/"):  # /~/x = path x relative to own home dir
             path = os.path.join(get_base_dir(), path[3:])
-        elif path.startswith("/~"):  # /~username/x = relative to "user" home dir
-            path = os.path.expanduser(path[1:])
         elif path.startswith("/./"):  # /./x = path x relative to cwd
             path = path[3:]
         return os.path.realpath(path)
diff --git a/src/borg/testsuite/helpers.py b/src/borg/testsuite/helpers.py
index 11e32cf1c..9247dbfc8 100644
--- a/src/borg/testsuite/helpers.py
+++ b/src/borg/testsuite/helpers.py
@@ -206,11 +206,6 @@ class TestLocationWithoutEnv:
             == "Location(proto='ssh', user='user', host='host', port=None, path='/~/some/path')"
         )
         assert Location("ssh://user@host/~/some/path").to_key_filename() == keys_dir + "host__some_path"
-        assert (
-            repr(Location("ssh://user@host/~user/some/path"))
-            == "Location(proto='ssh', user='user', host='host', port=None, path='/~user/some/path')"
-        )
-        assert Location("ssh://user@host/~user/some/path").to_key_filename() == keys_dir + "host__user_some_path"
 
     def test_with_colons(self, monkeypatch, keys_dir):
         monkeypatch.delenv("BORG_REPO", raising=False)

From 32a789657399b1c79fcd5a63079562daadc99eae Mon Sep 17 00:00:00 2001
From: Thomas Waldmann <tw@waldmann-edv.de>
Date: Sat, 16 Jul 2022 23:16:39 +0200
Subject: [PATCH 156/160] update CHANGES

---
 docs/changes.rst | 13 ++++++++++---
 1 file changed, 10 insertions(+), 3 deletions(-)

diff --git a/docs/changes.rst b/docs/changes.rst
index d9e40e4cd..abdf91e63 100644
--- a/docs/changes.rst
+++ b/docs/changes.rst
@@ -12,7 +12,7 @@ This section provides information about security and corruption issues.
 Change Log 2.x
 ==============
 
-Version 2.0.0a4 (2022-07-xx)
+Version 2.0.0a4 (2022-07-17)
 ----------------------------
 
 Please note:
@@ -38,6 +38,8 @@ Compatibility notes:
     call borg like: "borg -r <MYREPO> <COMMAND>".
     in the docs, we usually omit "-r ..." for brevity.
   - the scp-style REPO syntax was removed, please use ssh://..., #6697
+  - ssh:// URLs: removed support for /~otheruser/, #6855.
+    If you used this, just replace it by: ssh://user@host:port/home/otheruser/
   - -P / --prefix option was removed, please use the similar -a / --glob-archives.
   - differently than with borg 1.x you ONLY give the repo there, never a ::archive.
   - the archive name is either given as a positional parameter, like:
@@ -86,8 +88,13 @@ New features:
 Other changes:
 
 - stop using libdeflate
-- split up archiver module, transform it into a package
-- use Black for automated code formatting
+- CI: add mypy (if we add type hints, it can do type checking)
+- big changes to the source code:
+
+  - split up archiver module, transform it into a package
+  - use Black for automated code formatting
+  - remove some legacy code
+  - adapt/fix code for mypy
 - use language_level = 3str for cython (this will be the default in cython 3)
 - docs: document HardLinkManager and hlid, #2388
 

From 357aa5241b132ca7e9a949a2ac8ddc49d94f7e6b Mon Sep 17 00:00:00 2001
From: Thomas Waldmann <tw@waldmann-edv.de>
Date: Sun, 17 Jul 2022 09:23:06 +0200
Subject: [PATCH 157/160] build_usage / build_man

---
 docs/man/borg-benchmark-cpu.1         |   2 +-
 docs/man/borg-benchmark-crud.1        |   2 +-
 docs/man/borg-benchmark.1             |   2 +-
 docs/man/borg-break-lock.1            |   2 +-
 docs/man/borg-check.1                 |   2 +-
 docs/man/borg-common.1                |   2 +-
 docs/man/borg-compact.1               |   2 +-
 docs/man/borg-compression.1           |   2 +-
 docs/man/borg-config.1                |   2 +-
 docs/man/borg-create.1                |   2 +-
 docs/man/borg-delete.1                |   2 +-
 docs/man/borg-diff.1                  |   2 +-
 docs/man/borg-export-tar.1            |   2 +-
 docs/man/borg-extract.1               |   2 +-
 docs/man/borg-import-tar.1            |   2 +-
 docs/man/borg-info.1                  |   2 +-
 docs/man/borg-key-change-location.1   |   2 +-
 docs/man/borg-key-change-passphrase.1 |   2 +-
 docs/man/borg-key-export.1            |   2 +-
 docs/man/borg-key-import.1            |   2 +-
 docs/man/borg-key.1                   |   2 +-
 docs/man/borg-list.1                  |   2 +-
 docs/man/borg-mount.1                 |   2 +-
 docs/man/borg-patterns.1              |   2 +-
 docs/man/borg-placeholders.1          |   2 +-
 docs/man/borg-prune.1                 |   2 +-
 docs/man/borg-rcreate.1               |   2 +-
 docs/man/borg-rdelete.1               |   2 +-
 docs/man/borg-recreate.1              |   7 +-
 docs/man/borg-rename.1                |   2 +-
 docs/man/borg-rinfo.1                 |   2 +-
 docs/man/borg-rlist.1                 |   2 +-
 docs/man/borg-serve.1                 |   2 +-
 docs/man/borg-transfer.1              |   2 +-
 docs/man/borg-umount.1                |   2 +-
 docs/man/borg-with-lock.1             |   2 +-
 docs/man/borg.1                       |   4 +-
 docs/man/borgfs.1                     |  63 +------------
 docs/usage/recreate.rst.inc           | 123 +++++++++++++-------------
 39 files changed, 102 insertions(+), 165 deletions(-)

diff --git a/docs/man/borg-benchmark-cpu.1 b/docs/man/borg-benchmark-cpu.1
index ada06605c..539184728 100644
--- a/docs/man/borg-benchmark-cpu.1
+++ b/docs/man/borg-benchmark-cpu.1
@@ -27,7 +27,7 @@ level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .in \\n[rst2man-indent\\n[rst2man-indent-level]]u
 ..
-.TH "BORG-BENCHMARK-CPU" 1 "2022-07-03" "" "borg backup tool"
+.TH "BORG-BENCHMARK-CPU" 1 "2022-07-17" "" "borg backup tool"
 .SH NAME
 borg-benchmark-cpu \- Benchmark CPU bound operations.
 .SH SYNOPSIS
diff --git a/docs/man/borg-benchmark-crud.1 b/docs/man/borg-benchmark-crud.1
index 7dfc60ac5..29f20033e 100644
--- a/docs/man/borg-benchmark-crud.1
+++ b/docs/man/borg-benchmark-crud.1
@@ -27,7 +27,7 @@ level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .in \\n[rst2man-indent\\n[rst2man-indent-level]]u
 ..
-.TH "BORG-BENCHMARK-CRUD" 1 "2022-07-03" "" "borg backup tool"
+.TH "BORG-BENCHMARK-CRUD" 1 "2022-07-17" "" "borg backup tool"
 .SH NAME
 borg-benchmark-crud \- Benchmark Create, Read, Update, Delete for archives.
 .SH SYNOPSIS
diff --git a/docs/man/borg-benchmark.1 b/docs/man/borg-benchmark.1
index 97102ec3a..a3d64543e 100644
--- a/docs/man/borg-benchmark.1
+++ b/docs/man/borg-benchmark.1
@@ -27,7 +27,7 @@ level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .in \\n[rst2man-indent\\n[rst2man-indent-level]]u
 ..
-.TH "BORG-BENCHMARK" 1 "2022-07-03" "" "borg backup tool"
+.TH "BORG-BENCHMARK" 1 "2022-07-17" "" "borg backup tool"
 .SH NAME
 borg-benchmark \- benchmark command
 .SH SYNOPSIS
diff --git a/docs/man/borg-break-lock.1 b/docs/man/borg-break-lock.1
index 5af44e937..e8521a747 100644
--- a/docs/man/borg-break-lock.1
+++ b/docs/man/borg-break-lock.1
@@ -27,7 +27,7 @@ level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .in \\n[rst2man-indent\\n[rst2man-indent-level]]u
 ..
-.TH "BORG-BREAK-LOCK" 1 "2022-07-03" "" "borg backup tool"
+.TH "BORG-BREAK-LOCK" 1 "2022-07-17" "" "borg backup tool"
 .SH NAME
 borg-break-lock \- Break the repository lock (e.g. in case it was left by a dead borg.
 .SH SYNOPSIS
diff --git a/docs/man/borg-check.1 b/docs/man/borg-check.1
index a070031c9..8340cb3bc 100644
--- a/docs/man/borg-check.1
+++ b/docs/man/borg-check.1
@@ -27,7 +27,7 @@ level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .in \\n[rst2man-indent\\n[rst2man-indent-level]]u
 ..
-.TH "BORG-CHECK" 1 "2022-07-03" "" "borg backup tool"
+.TH "BORG-CHECK" 1 "2022-07-17" "" "borg backup tool"
 .SH NAME
 borg-check \- Check repository consistency
 .SH SYNOPSIS
diff --git a/docs/man/borg-common.1 b/docs/man/borg-common.1
index 80512171a..fefc34bcd 100644
--- a/docs/man/borg-common.1
+++ b/docs/man/borg-common.1
@@ -27,7 +27,7 @@ level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .in \\n[rst2man-indent\\n[rst2man-indent-level]]u
 ..
-.TH "BORG-COMMON" 1 "2022-07-03" "" "borg backup tool"
+.TH "BORG-COMMON" 1 "2022-07-17" "" "borg backup tool"
 .SH NAME
 borg-common \- Common options of Borg commands
 .SH SYNOPSIS
diff --git a/docs/man/borg-compact.1 b/docs/man/borg-compact.1
index a440b8c8d..87d5ea1e5 100644
--- a/docs/man/borg-compact.1
+++ b/docs/man/borg-compact.1
@@ -27,7 +27,7 @@ level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .in \\n[rst2man-indent\\n[rst2man-indent-level]]u
 ..
-.TH "BORG-COMPACT" 1 "2022-07-03" "" "borg backup tool"
+.TH "BORG-COMPACT" 1 "2022-07-17" "" "borg backup tool"
 .SH NAME
 borg-compact \- compact segment files in the repository
 .SH SYNOPSIS
diff --git a/docs/man/borg-compression.1 b/docs/man/borg-compression.1
index 7991b8ea8..a6ce53c98 100644
--- a/docs/man/borg-compression.1
+++ b/docs/man/borg-compression.1
@@ -27,7 +27,7 @@ level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .in \\n[rst2man-indent\\n[rst2man-indent-level]]u
 ..
-.TH "BORG-COMPRESSION" 1 "2022-07-03" "" "borg backup tool"
+.TH "BORG-COMPRESSION" 1 "2022-07-17" "" "borg backup tool"
 .SH NAME
 borg-compression \- Details regarding compression
 .SH DESCRIPTION
diff --git a/docs/man/borg-config.1 b/docs/man/borg-config.1
index 27a263ac5..bd9cca5e7 100644
--- a/docs/man/borg-config.1
+++ b/docs/man/borg-config.1
@@ -27,7 +27,7 @@ level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .in \\n[rst2man-indent\\n[rst2man-indent-level]]u
 ..
-.TH "BORG-CONFIG" 1 "2022-07-03" "" "borg backup tool"
+.TH "BORG-CONFIG" 1 "2022-07-17" "" "borg backup tool"
 .SH NAME
 borg-config \- get, set, and delete values in a repository or cache config file
 .SH SYNOPSIS
diff --git a/docs/man/borg-create.1 b/docs/man/borg-create.1
index c27aad5c7..c02d7934e 100644
--- a/docs/man/borg-create.1
+++ b/docs/man/borg-create.1
@@ -27,7 +27,7 @@ level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .in \\n[rst2man-indent\\n[rst2man-indent-level]]u
 ..
-.TH "BORG-CREATE" 1 "2022-07-03" "" "borg backup tool"
+.TH "BORG-CREATE" 1 "2022-07-17" "" "borg backup tool"
 .SH NAME
 borg-create \- Create new archive
 .SH SYNOPSIS
diff --git a/docs/man/borg-delete.1 b/docs/man/borg-delete.1
index ace74bd86..8c9fb2b90 100644
--- a/docs/man/borg-delete.1
+++ b/docs/man/borg-delete.1
@@ -27,7 +27,7 @@ level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .in \\n[rst2man-indent\\n[rst2man-indent-level]]u
 ..
-.TH "BORG-DELETE" 1 "2022-07-03" "" "borg backup tool"
+.TH "BORG-DELETE" 1 "2022-07-17" "" "borg backup tool"
 .SH NAME
 borg-delete \- Delete archives
 .SH SYNOPSIS
diff --git a/docs/man/borg-diff.1 b/docs/man/borg-diff.1
index f89e05735..df1dcce14 100644
--- a/docs/man/borg-diff.1
+++ b/docs/man/borg-diff.1
@@ -27,7 +27,7 @@ level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .in \\n[rst2man-indent\\n[rst2man-indent-level]]u
 ..
-.TH "BORG-DIFF" 1 "2022-07-03" "" "borg backup tool"
+.TH "BORG-DIFF" 1 "2022-07-17" "" "borg backup tool"
 .SH NAME
 borg-diff \- Diff contents of two archives
 .SH SYNOPSIS
diff --git a/docs/man/borg-export-tar.1 b/docs/man/borg-export-tar.1
index 2d49b41ef..86f01f142 100644
--- a/docs/man/borg-export-tar.1
+++ b/docs/man/borg-export-tar.1
@@ -27,7 +27,7 @@ level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .in \\n[rst2man-indent\\n[rst2man-indent-level]]u
 ..
-.TH "BORG-EXPORT-TAR" 1 "2022-07-03" "" "borg backup tool"
+.TH "BORG-EXPORT-TAR" 1 "2022-07-17" "" "borg backup tool"
 .SH NAME
 borg-export-tar \- Export archive contents as a tarball
 .SH SYNOPSIS
diff --git a/docs/man/borg-extract.1 b/docs/man/borg-extract.1
index 274087534..9c20e776e 100644
--- a/docs/man/borg-extract.1
+++ b/docs/man/borg-extract.1
@@ -27,7 +27,7 @@ level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .in \\n[rst2man-indent\\n[rst2man-indent-level]]u
 ..
-.TH "BORG-EXTRACT" 1 "2022-07-03" "" "borg backup tool"
+.TH "BORG-EXTRACT" 1 "2022-07-17" "" "borg backup tool"
 .SH NAME
 borg-extract \- Extract archive contents
 .SH SYNOPSIS
diff --git a/docs/man/borg-import-tar.1 b/docs/man/borg-import-tar.1
index 568b12149..0a1781142 100644
--- a/docs/man/borg-import-tar.1
+++ b/docs/man/borg-import-tar.1
@@ -27,7 +27,7 @@ level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .in \\n[rst2man-indent\\n[rst2man-indent-level]]u
 ..
-.TH "BORG-IMPORT-TAR" 1 "2022-07-03" "" "borg backup tool"
+.TH "BORG-IMPORT-TAR" 1 "2022-07-17" "" "borg backup tool"
 .SH NAME
 borg-import-tar \- Create a backup archive from a tarball
 .SH SYNOPSIS
diff --git a/docs/man/borg-info.1 b/docs/man/borg-info.1
index c32b057ea..152b51765 100644
--- a/docs/man/borg-info.1
+++ b/docs/man/borg-info.1
@@ -27,7 +27,7 @@ level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .in \\n[rst2man-indent\\n[rst2man-indent-level]]u
 ..
-.TH "BORG-INFO" 1 "2022-07-03" "" "borg backup tool"
+.TH "BORG-INFO" 1 "2022-07-17" "" "borg backup tool"
 .SH NAME
 borg-info \- Show archive details such as disk space used
 .SH SYNOPSIS
diff --git a/docs/man/borg-key-change-location.1 b/docs/man/borg-key-change-location.1
index 87d8873b8..891a93aef 100644
--- a/docs/man/borg-key-change-location.1
+++ b/docs/man/borg-key-change-location.1
@@ -27,7 +27,7 @@ level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .in \\n[rst2man-indent\\n[rst2man-indent-level]]u
 ..
-.TH "BORG-KEY-CHANGE-LOCATION" 1 "2022-07-03" "" "borg backup tool"
+.TH "BORG-KEY-CHANGE-LOCATION" 1 "2022-07-17" "" "borg backup tool"
 .SH NAME
 borg-key-change-location \- Change repository key location
 .SH SYNOPSIS
diff --git a/docs/man/borg-key-change-passphrase.1 b/docs/man/borg-key-change-passphrase.1
index ba93cbb7c..9f311d677 100644
--- a/docs/man/borg-key-change-passphrase.1
+++ b/docs/man/borg-key-change-passphrase.1
@@ -27,7 +27,7 @@ level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .in \\n[rst2man-indent\\n[rst2man-indent-level]]u
 ..
-.TH "BORG-KEY-CHANGE-PASSPHRASE" 1 "2022-07-03" "" "borg backup tool"
+.TH "BORG-KEY-CHANGE-PASSPHRASE" 1 "2022-07-17" "" "borg backup tool"
 .SH NAME
 borg-key-change-passphrase \- Change repository key file passphrase
 .SH SYNOPSIS
diff --git a/docs/man/borg-key-export.1 b/docs/man/borg-key-export.1
index 87d37244c..adf8a0a58 100644
--- a/docs/man/borg-key-export.1
+++ b/docs/man/borg-key-export.1
@@ -27,7 +27,7 @@ level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .in \\n[rst2man-indent\\n[rst2man-indent-level]]u
 ..
-.TH "BORG-KEY-EXPORT" 1 "2022-07-03" "" "borg backup tool"
+.TH "BORG-KEY-EXPORT" 1 "2022-07-17" "" "borg backup tool"
 .SH NAME
 borg-key-export \- Export the repository key for backup
 .SH SYNOPSIS
diff --git a/docs/man/borg-key-import.1 b/docs/man/borg-key-import.1
index a96de3c22..dc9528c28 100644
--- a/docs/man/borg-key-import.1
+++ b/docs/man/borg-key-import.1
@@ -27,7 +27,7 @@ level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .in \\n[rst2man-indent\\n[rst2man-indent-level]]u
 ..
-.TH "BORG-KEY-IMPORT" 1 "2022-07-03" "" "borg backup tool"
+.TH "BORG-KEY-IMPORT" 1 "2022-07-17" "" "borg backup tool"
 .SH NAME
 borg-key-import \- Import the repository key from backup
 .SH SYNOPSIS
diff --git a/docs/man/borg-key.1 b/docs/man/borg-key.1
index 3c8ea3c6e..43ef8f251 100644
--- a/docs/man/borg-key.1
+++ b/docs/man/borg-key.1
@@ -27,7 +27,7 @@ level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .in \\n[rst2man-indent\\n[rst2man-indent-level]]u
 ..
-.TH "BORG-KEY" 1 "2022-07-03" "" "borg backup tool"
+.TH "BORG-KEY" 1 "2022-07-17" "" "borg backup tool"
 .SH NAME
 borg-key \- Manage a keyfile or repokey of a repository
 .SH SYNOPSIS
diff --git a/docs/man/borg-list.1 b/docs/man/borg-list.1
index f2ad55de7..e1d948c13 100644
--- a/docs/man/borg-list.1
+++ b/docs/man/borg-list.1
@@ -27,7 +27,7 @@ level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .in \\n[rst2man-indent\\n[rst2man-indent-level]]u
 ..
-.TH "BORG-LIST" 1 "2022-07-03" "" "borg backup tool"
+.TH "BORG-LIST" 1 "2022-07-17" "" "borg backup tool"
 .SH NAME
 borg-list \- List archive contents
 .SH SYNOPSIS
diff --git a/docs/man/borg-mount.1 b/docs/man/borg-mount.1
index 8fff78e0a..348dd4ac0 100644
--- a/docs/man/borg-mount.1
+++ b/docs/man/borg-mount.1
@@ -27,7 +27,7 @@ level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .in \\n[rst2man-indent\\n[rst2man-indent-level]]u
 ..
-.TH "BORG-MOUNT" 1 "2022-07-03" "" "borg backup tool"
+.TH "BORG-MOUNT" 1 "2022-07-17" "" "borg backup tool"
 .SH NAME
 borg-mount \- Mount archive or an entire repository as a FUSE filesystem
 .SH SYNOPSIS
diff --git a/docs/man/borg-patterns.1 b/docs/man/borg-patterns.1
index a0b998af4..60f7dd415 100644
--- a/docs/man/borg-patterns.1
+++ b/docs/man/borg-patterns.1
@@ -27,7 +27,7 @@ level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .in \\n[rst2man-indent\\n[rst2man-indent-level]]u
 ..
-.TH "BORG-PATTERNS" 1 "2022-07-03" "" "borg backup tool"
+.TH "BORG-PATTERNS" 1 "2022-07-17" "" "borg backup tool"
 .SH NAME
 borg-patterns \- Details regarding patterns
 .SH DESCRIPTION
diff --git a/docs/man/borg-placeholders.1 b/docs/man/borg-placeholders.1
index 9d6b638a1..9ec6c65a3 100644
--- a/docs/man/borg-placeholders.1
+++ b/docs/man/borg-placeholders.1
@@ -27,7 +27,7 @@ level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .in \\n[rst2man-indent\\n[rst2man-indent-level]]u
 ..
-.TH "BORG-PLACEHOLDERS" 1 "2022-07-03" "" "borg backup tool"
+.TH "BORG-PLACEHOLDERS" 1 "2022-07-17" "" "borg backup tool"
 .SH NAME
 borg-placeholders \- Details regarding placeholders
 .SH DESCRIPTION
diff --git a/docs/man/borg-prune.1 b/docs/man/borg-prune.1
index 9bfcf63d2..beb7605e7 100644
--- a/docs/man/borg-prune.1
+++ b/docs/man/borg-prune.1
@@ -27,7 +27,7 @@ level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .in \\n[rst2man-indent\\n[rst2man-indent-level]]u
 ..
-.TH "BORG-PRUNE" 1 "2022-07-03" "" "borg backup tool"
+.TH "BORG-PRUNE" 1 "2022-07-17" "" "borg backup tool"
 .SH NAME
 borg-prune \- Prune repository archives according to specified rules
 .SH SYNOPSIS
diff --git a/docs/man/borg-rcreate.1 b/docs/man/borg-rcreate.1
index bc3ad14e6..0bc41e72d 100644
--- a/docs/man/borg-rcreate.1
+++ b/docs/man/borg-rcreate.1
@@ -27,7 +27,7 @@ level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .in \\n[rst2man-indent\\n[rst2man-indent-level]]u
 ..
-.TH "BORG-RCREATE" 1 "2022-07-03" "" "borg backup tool"
+.TH "BORG-RCREATE" 1 "2022-07-17" "" "borg backup tool"
 .SH NAME
 borg-rcreate \- Create a new, empty repository
 .SH SYNOPSIS
diff --git a/docs/man/borg-rdelete.1 b/docs/man/borg-rdelete.1
index 9b0ab8569..a410fc913 100644
--- a/docs/man/borg-rdelete.1
+++ b/docs/man/borg-rdelete.1
@@ -27,7 +27,7 @@ level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .in \\n[rst2man-indent\\n[rst2man-indent-level]]u
 ..
-.TH "BORG-RDELETE" 1 "2022-07-03" "" "borg backup tool"
+.TH "BORG-RDELETE" 1 "2022-07-17" "" "borg backup tool"
 .SH NAME
 borg-rdelete \- Delete a repository
 .SH SYNOPSIS
diff --git a/docs/man/borg-recreate.1 b/docs/man/borg-recreate.1
index c26cd79ab..608ec3b37 100644
--- a/docs/man/borg-recreate.1
+++ b/docs/man/borg-recreate.1
@@ -27,7 +27,7 @@ level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .in \\n[rst2man-indent\\n[rst2man-indent-level]]u
 ..
-.TH "BORG-RECREATE" 1 "2022-07-03" "" "borg backup tool"
+.TH "BORG-RECREATE" 1 "2022-07-17" "" "borg backup tool"
 .SH NAME
 borg-recreate \- Re-create archives
 .SH SYNOPSIS
@@ -56,8 +56,7 @@ incorrect information for archives that were not recreated at the same time.
 There is no risk of data loss by this.
 .sp
 \fB\-\-chunker\-params\fP will re\-chunk all files in the archive, this can be
-used to have upgraded Borg 0.xx or Attic archives deduplicate with
-Borg 1.x archives.
+used to have upgraded Borg 0.xx archives deduplicate with Borg 1.x archives.
 .sp
 \fBUSE WITH CAUTION.\fP
 Depending on the PATHs and patterns given, recreate can be used to permanently
@@ -164,7 +163,7 @@ manually specify the archive creation date/time (UTC, yyyy\-mm\-ddThh:mm:ss form
 select compression algorithm, see the output of the "borg help compression" command for details.
 .TP
 .BI \-\-recompress \ MODE
-recompress data chunks according to \fIMODE\fP and \fB\-\-compression\fP\&. Possible modes are \fIif\-different\fP: recompress if current compression is with a different compression algorithm (the level is not considered); \fIalways\fP: recompress even if current compression is with the same compression algorithm (use this to change the compression level); and \fInever\fP: do not recompress (use this option to explicitly prevent recompression). If no MODE is given, \fIif\-different\fP will be used. Not passing \-\-recompress is equivalent to "\-\-recompress never".
+recompress data chunks according to \fIMODE\fP and \fB\-\-compression\fP\&. Possible modes are \fIif\-different\fP: recompress if current compression is with a different compression algorithm or different level; \fIalways\fP: recompress unconditionally; and \fInever\fP: do not recompress (use this option to explicitly prevent recompression). If no MODE is given, \fIif\-different\fP will be used. Not passing \-\-recompress is equivalent to "\-\-recompress never".
 .TP
 .BI \-\-chunker\-params \ PARAMS
 specify the chunker parameters (ALGO, CHUNK_MIN_EXP, CHUNK_MAX_EXP, HASH_MASK_BITS, HASH_WINDOW_SIZE) or \fIdefault\fP to use the current defaults. default: buzhash,19,23,21,4095
diff --git a/docs/man/borg-rename.1 b/docs/man/borg-rename.1
index cbf7954a6..ad46e2888 100644
--- a/docs/man/borg-rename.1
+++ b/docs/man/borg-rename.1
@@ -27,7 +27,7 @@ level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .in \\n[rst2man-indent\\n[rst2man-indent-level]]u
 ..
-.TH "BORG-RENAME" 1 "2022-07-03" "" "borg backup tool"
+.TH "BORG-RENAME" 1 "2022-07-17" "" "borg backup tool"
 .SH NAME
 borg-rename \- Rename an existing archive
 .SH SYNOPSIS
diff --git a/docs/man/borg-rinfo.1 b/docs/man/borg-rinfo.1
index cab6310c0..e7bd04a99 100644
--- a/docs/man/borg-rinfo.1
+++ b/docs/man/borg-rinfo.1
@@ -27,7 +27,7 @@ level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .in \\n[rst2man-indent\\n[rst2man-indent-level]]u
 ..
-.TH "BORG-RINFO" 1 "2022-07-03" "" "borg backup tool"
+.TH "BORG-RINFO" 1 "2022-07-17" "" "borg backup tool"
 .SH NAME
 borg-rinfo \- Show repository infos
 .SH SYNOPSIS
diff --git a/docs/man/borg-rlist.1 b/docs/man/borg-rlist.1
index b7e4f5116..1db9b02c0 100644
--- a/docs/man/borg-rlist.1
+++ b/docs/man/borg-rlist.1
@@ -27,7 +27,7 @@ level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .in \\n[rst2man-indent\\n[rst2man-indent-level]]u
 ..
-.TH "BORG-RLIST" 1 "2022-07-03" "" "borg backup tool"
+.TH "BORG-RLIST" 1 "2022-07-17" "" "borg backup tool"
 .SH NAME
 borg-rlist \- List the archives contained in a repository
 .SH SYNOPSIS
diff --git a/docs/man/borg-serve.1 b/docs/man/borg-serve.1
index 524b2a194..3f6b3cfa6 100644
--- a/docs/man/borg-serve.1
+++ b/docs/man/borg-serve.1
@@ -27,7 +27,7 @@ level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .in \\n[rst2man-indent\\n[rst2man-indent-level]]u
 ..
-.TH "BORG-SERVE" 1 "2022-07-03" "" "borg backup tool"
+.TH "BORG-SERVE" 1 "2022-07-17" "" "borg backup tool"
 .SH NAME
 borg-serve \- Start in server mode. This command is usually not used manually.
 .SH SYNOPSIS
diff --git a/docs/man/borg-transfer.1 b/docs/man/borg-transfer.1
index 3c4e2a280..ca6fb77e5 100644
--- a/docs/man/borg-transfer.1
+++ b/docs/man/borg-transfer.1
@@ -27,7 +27,7 @@ level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .in \\n[rst2man-indent\\n[rst2man-indent-level]]u
 ..
-.TH "BORG-TRANSFER" 1 "2022-07-03" "" "borg backup tool"
+.TH "BORG-TRANSFER" 1 "2022-07-17" "" "borg backup tool"
 .SH NAME
 borg-transfer \- archives transfer from other repository, optionally upgrade data format
 .SH SYNOPSIS
diff --git a/docs/man/borg-umount.1 b/docs/man/borg-umount.1
index 73bdcd851..f69ff727c 100644
--- a/docs/man/borg-umount.1
+++ b/docs/man/borg-umount.1
@@ -27,7 +27,7 @@ level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .in \\n[rst2man-indent\\n[rst2man-indent-level]]u
 ..
-.TH "BORG-UMOUNT" 1 "2022-07-03" "" "borg backup tool"
+.TH "BORG-UMOUNT" 1 "2022-07-17" "" "borg backup tool"
 .SH NAME
 borg-umount \- un-mount the FUSE filesystem
 .SH SYNOPSIS
diff --git a/docs/man/borg-with-lock.1 b/docs/man/borg-with-lock.1
index 23caa35a7..b9b8fc86b 100644
--- a/docs/man/borg-with-lock.1
+++ b/docs/man/borg-with-lock.1
@@ -27,7 +27,7 @@ level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .in \\n[rst2man-indent\\n[rst2man-indent-level]]u
 ..
-.TH "BORG-WITH-LOCK" 1 "2022-07-03" "" "borg backup tool"
+.TH "BORG-WITH-LOCK" 1 "2022-07-17" "" "borg backup tool"
 .SH NAME
 borg-with-lock \- run a user specified command with the repository lock held
 .SH SYNOPSIS
diff --git a/docs/man/borg.1 b/docs/man/borg.1
index 713cfe135..446549a05 100644
--- a/docs/man/borg.1
+++ b/docs/man/borg.1
@@ -27,7 +27,7 @@ level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .in \\n[rst2man-indent\\n[rst2man-indent-level]]u
 ..
-.TH "BORG" 1 "2022-07-03" "" "borg backup tool"
+.TH "BORG" 1 "2022-07-17" "" "borg backup tool"
 .SH NAME
 borg \- deduplicating and encrypting backup tool
 .SH SYNOPSIS
@@ -238,8 +238,6 @@ Note: you may also prepend a \fBfile://\fP to a filesystem path to get URL style
 .sp
 \fBssh://user@host:port/~/path/to/repo\fP \- path relative to user\(aqs home directory
 .sp
-\fBssh://user@host:port/~other/path/to/repo\fP \- path relative to other\(aqs home directory
-.sp
 If you frequently need the same repo URL, it is a good idea to set the
 \fBBORG_REPO\fP environment variable to set a default for the repo URL:
 .INDENT 0.0
diff --git a/docs/man/borgfs.1 b/docs/man/borgfs.1
index 3af78caa3..fb8f92d0a 100644
--- a/docs/man/borgfs.1
+++ b/docs/man/borgfs.1
@@ -27,7 +27,7 @@ level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .in \\n[rst2man-indent\\n[rst2man-indent-level]]u
 ..
-.TH "BORGFS" 1 "2022-07-03" "" "borg backup tool"
+.TH "BORGFS" 1 "2022-07-17" "" "borg backup tool"
 .SH NAME
 borgfs \- Mount archive or an entire repository as a FUSE filesystem
 .SH SYNOPSIS
@@ -35,66 +35,7 @@ borgfs \- Mount archive or an entire repository as a FUSE filesystem
 borgfs [options] MOUNTPOINT [PATH...]
 .SH DESCRIPTION
 .sp
-This command mounts an archive as a FUSE filesystem. This can be useful
-for browsing an archive or restoring individual files. When restoring,
-take into account that the current FUSE implementation does not support
-special fs flags and ACLs.
-.sp
-Unless the \fB\-\-foreground\fP option is given the command will run in the
-background until the filesystem is \fBumounted\fP\&.
-.sp
-The command \fBborgfs\fP provides a wrapper for \fBborg mount\fP\&. This can also be
-used in fstab entries:
-\fB/path/to/repo /mnt/point fuse.borgfs defaults,noauto 0 0\fP
-.sp
-To allow a regular user to use fstab entries, add the \fBuser\fP option:
-\fB/path/to/repo /mnt/point fuse.borgfs defaults,noauto,user 0 0\fP
-.sp
-For FUSE configuration and mount options, see the mount.fuse(8) manual page.
-.sp
-Borg\(aqs default behavior is to use the archived user and group names of each
-file and map them to the system\(aqs respective user and group ids.
-Alternatively, using \fBnumeric\-ids\fP will instead use the archived user and
-group ids without any mapping.
-.sp
-The \fBuid\fP and \fBgid\fP mount options (implemented by Borg) can be used to
-override the user and group ids of all files (i.e., \fBborg mount \-o
-uid=1000,gid=1000\fP).
-.sp
-The man page references \fBuser_id\fP and \fBgroup_id\fP mount options
-(implemented by fuse) which specify the user and group id of the mount owner
-(aka, the user who does the mounting). It is set automatically by libfuse (or
-the filesystem if libfuse is not used). However, you should not specify these
-manually. Unlike the \fBuid\fP and \fBgid\fP mount options which affect all files,
-\fBuser_id\fP and \fBgroup_id\fP affect the user and group id of the mounted
-(base) directory.
-.sp
-Additional mount options supported by borg:
-.INDENT 0.0
-.IP \(bu 2
-versions: when used with a repository mount, this gives a merged, versioned
-view of the files in the archives. EXPERIMENTAL, layout may change in future.
-.IP \(bu 2
-allow_damaged_files: by default damaged files (where missing chunks were
-replaced with runs of zeros by borg check \fB\-\-repair\fP) are not readable and
-return EIO (I/O error). Set this option to read such files.
-.IP \(bu 2
-ignore_permissions: for security reasons the "default_permissions" mount
-option is internally enforced by borg. "ignore_permissions" can be given to
-not enforce "default_permissions".
-.UNINDENT
-.sp
-The BORG_MOUNT_DATA_CACHE_ENTRIES environment variable is meant for advanced users
-to tweak the performance. It sets the number of cached data chunks; additional
-memory usage can be up to ~8 MiB times this number. The default is the number
-of CPU cores.
-.sp
-When the daemonized process receives a signal or crashes, it does not unmount.
-Unmounting in these cases could cause an active rsync or similar process
-to unintentionally delete data.
-.sp
-When running in the foreground ^C/SIGINT unmounts cleanly, but other
-signals or crashes do not.
+For more information, see borg mount \-\-help.
 .SH OPTIONS
 .sp
 See \fIborg\-common(1)\fP for common options of Borg commands.
diff --git a/docs/usage/recreate.rst.inc b/docs/usage/recreate.rst.inc
index 0c6550654..fb973b17a 100644
--- a/docs/usage/recreate.rst.inc
+++ b/docs/usage/recreate.rst.inc
@@ -12,65 +12,65 @@ borg recreate
 
     .. class:: borg-options-table
 
-    +-----------------------------------------------------------------------------+---------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-    | **positional arguments**                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
-    +-----------------------------------------------------------------------------+---------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-    |                                                                             | ``PATH``                                          | paths to recreate; patterns are supported                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
-    +-----------------------------------------------------------------------------+---------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-    | **optional arguments**                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
-    +-----------------------------------------------------------------------------+---------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-    |                                                                             | ``--list``                                        | output verbose list of items (files, dirs, ...)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
-    +-----------------------------------------------------------------------------+---------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-    |                                                                             | ``--filter STATUSCHARS``                          | only display items with the given status characters (listed in borg create --help)                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
-    +-----------------------------------------------------------------------------+---------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-    |                                                                             | ``-n``, ``--dry-run``                             | do not change anything                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
-    +-----------------------------------------------------------------------------+---------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-    |                                                                             | ``-s``, ``--stats``                               | print statistics at end                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
-    +-----------------------------------------------------------------------------+---------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-    | .. class:: borg-common-opt-ref                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
-    |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
-    | :ref:`common_options`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
-    +-----------------------------------------------------------------------------+---------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-    | **Exclusion options**                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
-    +-----------------------------------------------------------------------------+---------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-    |                                                                             | ``-e PATTERN``, ``--exclude PATTERN``             | exclude paths matching PATTERN                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
-    +-----------------------------------------------------------------------------+---------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-    |                                                                             | ``--exclude-from EXCLUDEFILE``                    | read exclude patterns from EXCLUDEFILE, one per line                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
-    +-----------------------------------------------------------------------------+---------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-    |                                                                             | ``--pattern PATTERN``                             | include/exclude paths matching PATTERN                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
-    +-----------------------------------------------------------------------------+---------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-    |                                                                             | ``--patterns-from PATTERNFILE``                   | read include/exclude patterns from PATTERNFILE, one per line                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
-    +-----------------------------------------------------------------------------+---------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-    |                                                                             | ``--exclude-caches``                              | exclude directories that contain a CACHEDIR.TAG file (http://www.bford.info/cachedir/spec.html)                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
-    +-----------------------------------------------------------------------------+---------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-    |                                                                             | ``--exclude-if-present NAME``                     | exclude directories that are tagged by containing a filesystem object with the given NAME                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
-    +-----------------------------------------------------------------------------+---------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-    |                                                                             | ``--keep-exclude-tags``                           | if tag objects are specified with ``--exclude-if-present``, don't omit the tag objects themselves from the backup archive                                                                                                                                                                                                                                                                                                                                                                                                                                   |
-    +-----------------------------------------------------------------------------+---------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-    | **Archive filters** — Archive filters can be applied to repository targets.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
-    +-----------------------------------------------------------------------------+---------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-    |                                                                             | ``-a GLOB``, ``--glob-archives GLOB``             | only consider archive names matching the glob. sh: rules apply, see "borg help patterns".                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
-    +-----------------------------------------------------------------------------+---------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-    |                                                                             | ``--sort-by KEYS``                                | Comma-separated list of sorting keys; valid keys are: timestamp, name, id; default is: timestamp                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
-    +-----------------------------------------------------------------------------+---------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-    |                                                                             | ``--first N``                                     | consider first N archives after other filters were applied                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
-    +-----------------------------------------------------------------------------+---------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-    |                                                                             | ``--last N``                                      | consider last N archives after other filters were applied                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
-    +-----------------------------------------------------------------------------+---------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-    |                                                                             | ``--target TARGET``                               | create a new archive with the name ARCHIVE, do not replace existing archive (only applies for a single archive)                                                                                                                                                                                                                                                                                                                                                                                                                                             |
-    +-----------------------------------------------------------------------------+---------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-    |                                                                             | ``-c SECONDS``, ``--checkpoint-interval SECONDS`` | write checkpoint every SECONDS seconds (Default: 1800)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
-    +-----------------------------------------------------------------------------+---------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-    |                                                                             | ``--comment COMMENT``                             | add a comment text to the archive                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
-    +-----------------------------------------------------------------------------+---------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-    |                                                                             | ``--timestamp TIMESTAMP``                         | manually specify the archive creation date/time (UTC, yyyy-mm-ddThh:mm:ss format). alternatively, give a reference file/directory.                                                                                                                                                                                                                                                                                                                                                                                                                          |
-    +-----------------------------------------------------------------------------+---------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-    |                                                                             | ``-C COMPRESSION``, ``--compression COMPRESSION`` | select compression algorithm, see the output of the "borg help compression" command for details.                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
-    +-----------------------------------------------------------------------------+---------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-    |                                                                             | ``--recompress MODE``                             | recompress data chunks according to `MODE` and ``--compression``. Possible modes are `if-different`: recompress if current compression is with a different compression algorithm (the level is not considered); `always`: recompress even if current compression is with the same compression algorithm (use this to change the compression level); and `never`: do not recompress (use this option to explicitly prevent recompression). If no MODE is given, `if-different` will be used. Not passing --recompress is equivalent to "--recompress never". |
-    +-----------------------------------------------------------------------------+---------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-    |                                                                             | ``--chunker-params PARAMS``                       | specify the chunker parameters (ALGO, CHUNK_MIN_EXP, CHUNK_MAX_EXP, HASH_MASK_BITS, HASH_WINDOW_SIZE) or `default` to use the current defaults. default: buzhash,19,23,21,4095                                                                                                                                                                                                                                                                                                                                                                              |
-    +-----------------------------------------------------------------------------+---------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+    +-----------------------------------------------------------------------------+---------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+    | **positional arguments**                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
+    +-----------------------------------------------------------------------------+---------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+    |                                                                             | ``PATH``                                          | paths to recreate; patterns are supported                                                                                                                                                                                                                                                                                                                                                                                                          |
+    +-----------------------------------------------------------------------------+---------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+    | **optional arguments**                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
+    +-----------------------------------------------------------------------------+---------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+    |                                                                             | ``--list``                                        | output verbose list of items (files, dirs, ...)                                                                                                                                                                                                                                                                                                                                                                                                    |
+    +-----------------------------------------------------------------------------+---------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+    |                                                                             | ``--filter STATUSCHARS``                          | only display items with the given status characters (listed in borg create --help)                                                                                                                                                                                                                                                                                                                                                                 |
+    +-----------------------------------------------------------------------------+---------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+    |                                                                             | ``-n``, ``--dry-run``                             | do not change anything                                                                                                                                                                                                                                                                                                                                                                                                                             |
+    +-----------------------------------------------------------------------------+---------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+    |                                                                             | ``-s``, ``--stats``                               | print statistics at end                                                                                                                                                                                                                                                                                                                                                                                                                            |
+    +-----------------------------------------------------------------------------+---------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+    | .. class:: borg-common-opt-ref                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
+    |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
+    | :ref:`common_options`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
+    +-----------------------------------------------------------------------------+---------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+    | **Exclusion options**                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
+    +-----------------------------------------------------------------------------+---------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+    |                                                                             | ``-e PATTERN``, ``--exclude PATTERN``             | exclude paths matching PATTERN                                                                                                                                                                                                                                                                                                                                                                                                                     |
+    +-----------------------------------------------------------------------------+---------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+    |                                                                             | ``--exclude-from EXCLUDEFILE``                    | read exclude patterns from EXCLUDEFILE, one per line                                                                                                                                                                                                                                                                                                                                                                                               |
+    +-----------------------------------------------------------------------------+---------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+    |                                                                             | ``--pattern PATTERN``                             | include/exclude paths matching PATTERN                                                                                                                                                                                                                                                                                                                                                                                                             |
+    +-----------------------------------------------------------------------------+---------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+    |                                                                             | ``--patterns-from PATTERNFILE``                   | read include/exclude patterns from PATTERNFILE, one per line                                                                                                                                                                                                                                                                                                                                                                                       |
+    +-----------------------------------------------------------------------------+---------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+    |                                                                             | ``--exclude-caches``                              | exclude directories that contain a CACHEDIR.TAG file (http://www.bford.info/cachedir/spec.html)                                                                                                                                                                                                                                                                                                                                                    |
+    +-----------------------------------------------------------------------------+---------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+    |                                                                             | ``--exclude-if-present NAME``                     | exclude directories that are tagged by containing a filesystem object with the given NAME                                                                                                                                                                                                                                                                                                                                                          |
+    +-----------------------------------------------------------------------------+---------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+    |                                                                             | ``--keep-exclude-tags``                           | if tag objects are specified with ``--exclude-if-present``, don't omit the tag objects themselves from the backup archive                                                                                                                                                                                                                                                                                                                          |
+    +-----------------------------------------------------------------------------+---------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+    | **Archive filters** — Archive filters can be applied to repository targets.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
+    +-----------------------------------------------------------------------------+---------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+    |                                                                             | ``-a GLOB``, ``--glob-archives GLOB``             | only consider archive names matching the glob. sh: rules apply, see "borg help patterns".                                                                                                                                                                                                                                                                                                                                                          |
+    +-----------------------------------------------------------------------------+---------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+    |                                                                             | ``--sort-by KEYS``                                | Comma-separated list of sorting keys; valid keys are: timestamp, name, id; default is: timestamp                                                                                                                                                                                                                                                                                                                                                   |
+    +-----------------------------------------------------------------------------+---------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+    |                                                                             | ``--first N``                                     | consider first N archives after other filters were applied                                                                                                                                                                                                                                                                                                                                                                                         |
+    +-----------------------------------------------------------------------------+---------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+    |                                                                             | ``--last N``                                      | consider last N archives after other filters were applied                                                                                                                                                                                                                                                                                                                                                                                          |
+    +-----------------------------------------------------------------------------+---------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+    |                                                                             | ``--target TARGET``                               | create a new archive with the name ARCHIVE, do not replace existing archive (only applies for a single archive)                                                                                                                                                                                                                                                                                                                                    |
+    +-----------------------------------------------------------------------------+---------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+    |                                                                             | ``-c SECONDS``, ``--checkpoint-interval SECONDS`` | write checkpoint every SECONDS seconds (Default: 1800)                                                                                                                                                                                                                                                                                                                                                                                             |
+    +-----------------------------------------------------------------------------+---------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+    |                                                                             | ``--comment COMMENT``                             | add a comment text to the archive                                                                                                                                                                                                                                                                                                                                                                                                                  |
+    +-----------------------------------------------------------------------------+---------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+    |                                                                             | ``--timestamp TIMESTAMP``                         | manually specify the archive creation date/time (UTC, yyyy-mm-ddThh:mm:ss format). alternatively, give a reference file/directory.                                                                                                                                                                                                                                                                                                                 |
+    +-----------------------------------------------------------------------------+---------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+    |                                                                             | ``-C COMPRESSION``, ``--compression COMPRESSION`` | select compression algorithm, see the output of the "borg help compression" command for details.                                                                                                                                                                                                                                                                                                                                                   |
+    +-----------------------------------------------------------------------------+---------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+    |                                                                             | ``--recompress MODE``                             | recompress data chunks according to `MODE` and ``--compression``. Possible modes are `if-different`: recompress if current compression is with a different compression algorithm or different level; `always`: recompress unconditionally; and `never`: do not recompress (use this option to explicitly prevent recompression). If no MODE is given, `if-different` will be used. Not passing --recompress is equivalent to "--recompress never". |
+    +-----------------------------------------------------------------------------+---------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+    |                                                                             | ``--chunker-params PARAMS``                       | specify the chunker parameters (ALGO, CHUNK_MIN_EXP, CHUNK_MAX_EXP, HASH_MASK_BITS, HASH_WINDOW_SIZE) or `default` to use the current defaults. default: buzhash,19,23,21,4095                                                                                                                                                                                                                                                                     |
+    +-----------------------------------------------------------------------------+---------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
 
     .. raw:: html
 
@@ -116,7 +116,7 @@ borg recreate
         --comment COMMENT                             add a comment text to the archive
         --timestamp TIMESTAMP                         manually specify the archive creation date/time (UTC, yyyy-mm-ddThh:mm:ss format). alternatively, give a reference file/directory.
         -C COMPRESSION, --compression COMPRESSION     select compression algorithm, see the output of the "borg help compression" command for details.
-        --recompress MODE                             recompress data chunks according to `MODE` and ``--compression``. Possible modes are `if-different`: recompress if current compression is with a different compression algorithm (the level is not considered); `always`: recompress even if current compression is with the same compression algorithm (use this to change the compression level); and `never`: do not recompress (use this option to explicitly prevent recompression). If no MODE is given, `if-different` will be used. Not passing --recompress is equivalent to "--recompress never".
+        --recompress MODE                             recompress data chunks according to `MODE` and ``--compression``. Possible modes are `if-different`: recompress if current compression is with a different compression algorithm or different level; `always`: recompress unconditionally; and `never`: do not recompress (use this option to explicitly prevent recompression). If no MODE is given, `if-different` will be used. Not passing --recompress is equivalent to "--recompress never".
         --chunker-params PARAMS                       specify the chunker parameters (ALGO, CHUNK_MIN_EXP, CHUNK_MAX_EXP, HASH_MASK_BITS, HASH_WINDOW_SIZE) or `default` to use the current defaults. default: buzhash,19,23,21,4095
 
 
@@ -144,8 +144,7 @@ incorrect information for archives that were not recreated at the same time.
 There is no risk of data loss by this.
 
 ``--chunker-params`` will re-chunk all files in the archive, this can be
-used to have upgraded Borg 0.xx or Attic archives deduplicate with
-Borg 1.x archives.
+used to have upgraded Borg 0.xx archives deduplicate with Borg 1.x archives.
 
 **USE WITH CAUTION.**
 Depending on the PATHs and patterns given, recreate can be used to permanently

From f82f123b56856aac1fee4f14d96500d648e71dcb Mon Sep 17 00:00:00 2001
From: Thomas Waldmann <tw@waldmann-edv.de>
Date: Wed, 20 Jul 2022 14:13:25 +0200
Subject: [PATCH 158/160] new crypto does not need to call ._assert_id()

https://github.com/borgbackup/borg/pull/6463#discussion_r925436156
---
 src/borg/crypto/key.py    |  5 ++++-
 src/borg/testsuite/key.py | 21 +++++++++++++++++++++
 2 files changed, 25 insertions(+), 1 deletion(-)

diff --git a/src/borg/crypto/key.py b/src/borg/crypto/key.py
index 882c595e2..2def782f0 100644
--- a/src/borg/crypto/key.py
+++ b/src/borg/crypto/key.py
@@ -871,7 +871,10 @@ class AEADKeyBase(KeyBase):
         if not decompress:
             return payload
         data = self.decompress(memoryview(payload))
-        self.assert_id(id, data)
+        # note: calling self.assert_id(id, data) is not needed any more for the new AEAD crypto.
+        # we put the id into AAD when storing the chunk, so it gets into the authentication tag computation.
+        # when decrypting, we provide the id we **want** as AAD for the auth tag verification, so
+        # decrypting only succeeds if we got the ciphertext we wrote **for that chunk id**.
         return data
 
     def init_from_given_data(self, *, enc_key, enc_hmac_key, id_key, chunk_seed):
diff --git a/src/borg/testsuite/key.py b/src/borg/testsuite/key.py
index 512649232..a0b41ca6c 100644
--- a/src/borg/testsuite/key.py
+++ b/src/borg/testsuite/key.py
@@ -256,6 +256,27 @@ class TestKey:
         with pytest.raises(IntegrityError):
             key.assert_id(id, plaintext_changed)
 
+    def test_getting_wrong_chunk_fails(self, key):
+        # for the new AEAD crypto, we provide the chunk id as AAD when encrypting/authenticating,
+        # we provide the id **we want** as AAD when authenticating/decrypting the data we got from the repo.
+        # only if the id used for encrypting matches the id we want, the AEAD crypto authentication will succeed.
+        # thus, there is no need any more for calling self._assert_id() for the new crypto.
+        # the old crypto as well as plaintext and authenticated modes still need to call self._assert_id().
+        plaintext_wanted = b"123456789"
+        id_wanted = key.id_hash(plaintext_wanted)
+        ciphertext_wanted = key.encrypt(id_wanted, plaintext_wanted)
+        plaintext_other = b"xxxxxxxxx"
+        id_other = key.id_hash(plaintext_other)
+        ciphertext_other = key.encrypt(id_other, plaintext_other)
+        # both ciphertexts are authentic and decrypting them should succeed:
+        key.decrypt(id_wanted, ciphertext_wanted)
+        key.decrypt(id_other, ciphertext_other)
+        # but if we wanted the one and got the other, it must fail.
+        # the new crypto will fail due to AEAD auth failure,
+        # the old crypto and plaintext, authenticated modes will fail due to ._assert_id() check failing:
+        with pytest.raises(IntegrityErrorBase):
+            key.decrypt(id_wanted, ciphertext_other)
+
     def test_authenticated_encrypt(self, monkeypatch):
         monkeypatch.setenv("BORG_PASSPHRASE", "test")
         key = AuthenticatedKey.create(self.MockRepository(), self.MockArgs())

From 9d6c98d9f915e5c8a44d1a048e0ef2d9b254889f Mon Sep 17 00:00:00 2001
From: Thomas Waldmann <tw@waldmann-edv.de>
Date: Wed, 20 Jul 2022 14:31:37 +0200
Subject: [PATCH 159/160] docs: remove _assert_id() call for new crypto

---
 docs/internals/security.rst | 2 --
 1 file changed, 2 deletions(-)

diff --git a/docs/internals/security.rst b/docs/internals/security.rst
index b7b247d0e..e8b9bbf05 100644
--- a/docs/internals/security.rst
+++ b/docs/internals/security.rst
@@ -180,8 +180,6 @@ Decryption::
 
     decompressed = decompress(decrypted)
 
-    ASSERT( CONSTANT-TIME-COMPARISON( chunk-id, MAC(id_key, decompressed) ) )
-
 Notable:
 
 - More modern and often faster AEAD ciphers instead of self-assembled stuff.

From b0db800b5a0987f525f1117d0b13075b74ddadb6 Mon Sep 17 00:00:00 2001
From: Thomas Waldmann <tw@waldmann-edv.de>
Date: Wed, 20 Jul 2022 14:53:50 +0200
Subject: [PATCH 160/160] check: --verify-data does not need to decompress with
 new crypto modes

---
 src/borg/archive.py | 12 +++++++++---
 1 file changed, 9 insertions(+), 3 deletions(-)

diff --git a/src/borg/archive.py b/src/borg/archive.py
index f6a7a900d..7c6b832b0 100644
--- a/src/borg/archive.py
+++ b/src/borg/archive.py
@@ -21,7 +21,7 @@ logger = create_logger()
 from . import xattr
 from .chunker import get_chunker, Chunk
 from .cache import ChunkListEntry
-from .crypto.key import key_factory
+from .crypto.key import key_factory, AEADKeyBase
 from .compress import Compressor, CompressionSpec
 from .constants import *  # NOQA
 from .crypto.low_level import IntegrityError as IntegrityErrorBase
@@ -1684,6 +1684,12 @@ class ArchiveChecker:
         chunks_count_index = len(self.chunks)
         chunks_count_segments = 0
         errors = 0
+        # for the new crypto, derived from AEADKeyBase, we know that it checks authenticity on
+        # the crypto.low_level level - invalid chunks will fail to AEAD authenticate.
+        # for these key types, we know that there is no need to decompress the data afterwards.
+        # for all other modes, we assume that we must decompress, so we can verify authenticity
+        # based on the plaintext MAC (via calling ._assert_id(id, plaintext)).
+        decompress = not isinstance(self.key, AEADKeyBase)
         defect_chunks = []
         pi = ProgressIndicatorPercent(
             total=chunks_count_index, msg="Verifying data %6.2f%%", step=0.01, msgid="check.verify_data"
@@ -1714,7 +1720,7 @@ class ArchiveChecker:
                         chunk_data_iter = self.repository.get_many(chunk_ids)
                 else:
                     try:
-                        self.key.decrypt(chunk_id, encrypted_data)
+                        self.key.decrypt(chunk_id, encrypted_data, decompress=decompress)
                     except IntegrityErrorBase as integrity_error:
                         self.error_found = True
                         errors += 1
@@ -1745,7 +1751,7 @@ class ArchiveChecker:
                     # from the underlying media.
                     try:
                         encrypted_data = self.repository.get(defect_chunk)
-                        self.key.decrypt(defect_chunk, encrypted_data)
+                        self.key.decrypt(defect_chunk, encrypted_data, decompress=decompress)
                     except IntegrityErrorBase:
                         # failed twice -> get rid of this chunk
                         del self.chunks[defect_chunk]